text,length,is_long_context,metric_val,label_metric
"/*
Feathers
Copyright 2012-2021 Bowler Hat LLC. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.controls.supportClasses
{
	import feathers.controls.Scroller;
	import feathers.controls.Tree;
	import feathers.controls.renderers.ITreeItemRenderer;
	import feathers.core.FeathersControl;
	import feathers.core.IFeathersControl;
	import feathers.core.IValidating;
	import feathers.data.IHierarchicalCollection;
	import feathers.data.IListCollection;
	import feathers.events.FeathersEventType;
	import feathers.layout.ILayout;
	import feathers.layout.IVariableVirtualLayout;
	import feathers.layout.IVirtualLayout;
	import feathers.layout.LayoutBoundsResult;
	import feathers.layout.ViewPortBounds;

	import flash.errors.IllegalOperationError;
	import flash.geom.Point;
	import flash.utils.Dictionary;

	import starling.display.DisplayObject;
	import starling.events.Event;
	import starling.utils.Pool;

	/**
	 * @private
	 * Used internally by Tree. Not meant to be used on its own.
	 *
	 * @productversion Feathers 3.3.0
	 */
	public class TreeDataViewPort extends FeathersControl implements IViewPort
	{
		private static const INVALIDATION_FLAG_ITEM_RENDERER_FACTORY:String = ""itemRendererFactory"";
		private static const HELPER_VECTOR:Vector.<int> = new <int>[];
		private static const LOCATION_HELPER_VECTOR:Vector.<int> = new <int>[];

		public function TreeDataViewPort()
		{
			super();
		}

		private var _viewPortBounds:ViewPortBounds = new ViewPortBounds();

		private var _layoutResult:LayoutBoundsResult = new LayoutBoundsResult();

		private var _actualMinVisibleWidth:Number = 0;

		private var _explicitMinVisibleWidth:Number;

		public function get minVisibleWidth():Number
		{
			if(this._explicitMinVisibleWidth !== this._explicitMinVisibleWidth) //isNaN
			{
				return this._actualMinVisibleWidth;
			}
			return this._explicitMinVisibleWidth;
		}

		public function set minVisibleWidth(value:Number):void
		{
			if(this._explicitMinVisibleWidth == value)
			{
				return;
			}
			var valueIsNaN:Boolean = value !== value; //isNaN
			if(valueIsNaN &&
				this._explicitMinVisibleWidth !== this._explicitMinVisibleWidth) //isNaN
			{
				return;
			}
			var oldValue:Number = this._explicitMinVisibleWidth;
			this._explicitMinVisibleWidth = value;
			if(valueIsNaN)
			{
				this._actualMinVisibleWidth = 0;
				this.invalidate(INVALIDATION_FLAG_SIZE);
			}
			else
			{
				this._actualMinVisibleWidth = value;
				if(this._explicitVisibleWidth !== this._explicitVisibleWidth && //isNaN
					(this._actualVisibleWidth < value || this._actualVisibleWidth == oldValue))
				{
					//only invalidate if this change might affect the visibleWidth
					this.invalidate(INVALIDATION_FLAG_SIZE);
				}
			}
		}

		private var _maxVisibleWidth:Number = Number.POSITIVE_INFINITY;

		public function get maxVisibleWidth():Number
		{
			return this._maxVisibleWidth;
		}

		public function set maxVisibleWidth(value:Number):void
		{
			if(this._maxVisibleWidth == value)
			{
				return;
			}
			if(value !== value) //isNaN
			{
				throw new ArgumentError(""maxVisibleWidth cannot be NaN"");
			}
			var oldValue:Number = this._maxVisibleWidth;
			this._maxVisibleWidth = value;
			if(this._explicitVisibleWidth !== this._explicitVisibleWidth && //isNaN
				(this._actualVisibleWidth > value || this._actualVisibleWidth == oldValue))
			{
				//only invalidate if this change might affect the visibleWidth
				this.invalidate(INVALIDATION_FLAG_SIZE);
			}
		}

		private var _actualVisibleWidth:Number = NaN;

		private var _explicitVisibleWidth:Number = NaN;

		public function get visibleWidth():Number
		{
			return this._actualVisibleWidth;
		}

		public function set visibleWidth(value:Number):void
		{
			if(this._explicitVisibleWidth == value ||
				(value !== value && this._explicitVisibleWidth !== this._explicitVisibleWidth)) //isNaN
			{
				return;
			}
			this._explicitVisibleWidth = value;
			if(this._actualVisibleWidth != value)
			{
				this.invalidate(INVALIDATION_FLAG_SIZE);
			}
		}

		private var _actualMinVisibleHeight:Number = 0;

		private var _explicitMinVisibleHeight:Number;

		public function get minVisibleHeight():Number
		{
			if(this._explicitMinVisibleHeight !== this._explicitMinVisibleHeight) //isNaN
			{
				return this._actualMinVisibleHeight;
			}
			return this._explicitMinVisibleHeight;
		}

		public function set minVisibleHeight(value:Number):void
		{
			if(this._explicitMinVisibleHeight == value)
			{
				return;
			}
			var valueIsNaN:Boolean = value !== value; //isNaN
			if(valueIsNaN &&
				this._explicitMinVisibleHeight !== this._explicitMinVisibleHeight) //isNaN
			{
				return;
			}
			var oldValue:Number = this._explicitMinVisibleHeight;
			this._explicitMinVisibleHeight = value;
			if(valueIsNaN)
			{
				this._actualMinVisibleHeight = 0;
				this.invalidate(INVALIDATION_FLAG_SIZE);
			}
			else
			{
				this._actualMinVisibleHeight = value;
				if(this._explicitVisibleHeight !== this._explicitVisibleHeight && //isNaN
					(this._actualVisibleHeight < value || this._actualVisibleHeight == oldValue))
				{
					//only invalidate if this change might affect the visibleHeight
					this.invalidate(INVALIDATION_FLAG_SIZE);
				}
			}
		}

		private var _maxVisibleHeight:Number = Number.POSITIVE_INFINITY;

		public function get maxVisibleHeight():Number
		{
			return this._maxVisibleHeight;
		}

		public function set maxVisibleHeight(value:Number):void
		{
			if(this._maxVisibleHeight == value)
			{
				return;
			}
			if(value !== value) //isNaN
			{
				throw new ArgumentError(""maxVisibleHeight cannot be NaN"");
			}
			var oldValue:Number = this._maxVisibleHeight;
			this._maxVisibleHeight = value;
			if(this._explicitVisibleHeight !== this._explicitVisibleHeight && //isNaN
				(this._actualVisibleHeight > value || this._actualVisibleHeight == oldValue))
			{
				//only invalidate if this change might affect the visibleHeight
				this.invalidate(INVALIDATION_FLAG_SIZE);
			}
		}

		private var _actualVisibleHeight:Number;

		private var _explicitVisibleHeight:Number = NaN;

		public function get visibleHeight():Number
		{
			return this._actualVisibleHeight;
		}

		public function set visibleHeight(value:Number):void
		{
			if(this._explicitVisibleHeight == value ||
				(value !== value && this._explicitVisibleHeight !== this._explicitVisibleHeight)) //isNaN
			{
				return;
			}
			this._explicitVisibleHeight = value;
			if(this._actualVisibleHeight != value)
			{
				this.invalidate(INVALIDATION_FLAG_SIZE);
			}
		}

		protected var _contentX:Number = 0;

		public function get contentX():Number
		{
			return this._contentX;
		}

		protected var _contentY:Number = 0;

		public function get contentY():Number
		{
			return this._contentY;
		}

		public function get horizontalScrollStep():Number
		{
			var itemRenderer:DisplayObject = null;
			var virtualLayout:IVirtualLayout = this._layout as IVirtualLayout;
			if(virtualLayout === null || !virtualLayout.useVirtualLayout)
			{
				if(this._layoutItems.length > 0)
				{
					itemRenderer = this._layoutItems[0] as DisplayObject;
				}
			}
			if(itemRenderer === null)
			{
				itemRenderer = this._typicalItemRenderer as DisplayObject;
			}
			if(itemRenderer === null)
			{
				return 0;
			}
			var itemRendererWidth:Number = itemRenderer.width;
			var itemRendererHeight:Number = itemRenderer.height;
			if(itemRendererWidth < itemRendererHeight)
			{
				return itemRendererWidth;
			}
			return itemRendererHeight;
		}

		public function get verticalScrollStep():Number
		{
			var itemRenderer:DisplayObject = null;
			var virtualLayout:IVirtualLayout = this._layout as IVirtualLayout;
			if(virtualLayout === null || !virtualLayout.useVirtualLayout)
			{
				if(this._layoutItems.length > 0)
				{
					itemRenderer = this._layoutItems[0] as DisplayObject;
				}
			}
			if(itemRenderer === null)
			{
				itemRenderer = this._typicalItemRenderer as DisplayObject;
			}
			if(itemRenderer === null)
			{
				return 0;
			}
			var itemRendererWidth:Number = itemRenderer.width;
			var itemRendererHeight:Number = itemRenderer.height;
			if(itemRendererWidth < itemRendererHeight)
			{
				return itemRendererWidth;
			}
			return itemRendererHeight;
		}

		private var _owner:Tree = null;

		public function get owner():Tree
		{
			return this._owner;
		}

		public function set owner(value:Tree):void
		{
			this._owner = value;
		}

		private var _updateForDataReset:Boolean = false;

		private var _dataProvider:IHierarchicalCollection = null;

		public function get dataProvider():IHierarchicalCollection
		{
			return this._dataProvider;
		}

		public function set dataProvider(value:IHierarchicalCollection):void
		{
			if(this._dataProvider == value)
			{
				return;
			}
			if(this._dataProvider)
			{
				this._dataProvider.removeEventListener(Event.CHANGE, dataProvider_changeHandler);
				/*this._dataProvider.removeEventListener(CollectionEventType.RESET, dataProvider_resetHandler);
				this._dataProvider.removeEventListener(CollectionEventType.ADD_ITEM, dataProvider_addItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.REMOVE_ITEM, dataProvider_removeItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.REPLACE_ITEM, dataProvider_replaceItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.UPDATE_ITEM, dataProvider_updateItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.UPDATE_ALL, dataProvider_updateAllHandler);*/
			}
			this._dataProvider = value;
			if(this._dataProvider)
			{
				this._dataProvider.addEventListener(Event.CHANGE, dataProvider_changeHandler);
				/*this._dataProvider.addEventListener(CollectionEventType.RESET, dataProvider_resetHandler);
				this._dataProvider.addEventListener(CollectionEventType.ADD_ITEM, dataProvider_addItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.REMOVE_ITEM, dataProvider_removeItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.REPLACE_ITEM, dataProvider_replaceItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.UPDATE_ITEM, dataProvider_updateItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.UPDATE_ALL, dataProvider_updateAllHandler);*/
			}
			if(this._layout is IVariableVirtualLayout)
			{
				IVariableVirtualLayout(this._layout).resetVariableVirtualCache();
			}
			this._updateForDataReset = true;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		private var _ignoreLayoutChanges:Boolean = false;
		private var _ignoreRendererResizing:Boolean = false;

		private var _layout:ILayout = null;

		public function get layout():ILayout
		{
			return this._layout;
		}

		public function set layout(value:ILayout):void
		{
			if(this._layout == value)
			{
				return;
			}
			if(this._layout)
			{
				this._layout.removeEventListener(Event.CHANGE, layout_changeHandler);
			}
			this._layout = value;
			if(this._layout)
			{
				if(this._layout is IVariableVirtualLayout)
				{
					var variableVirtualLayout:IVariableVirtualLayout = IVariableVirtualLayout(this._layout);
					variableVirtualLayout.resetVariableVirtualCache();
				}
				this._layout.addEventListener(Event.CHANGE, layout_changeHandler);
			}
			this.invalidate(INVALIDATION_FLAG_LAYOUT);
		}

		private var _horizontalScrollPosition:Number = 0;

		public function get horizontalScrollPosition():Number
		{
			return this._horizontalScrollPosition;
		}

		public function set horizontalScrollPosition(value:Number):void
		{
			if(this._horizontalScrollPosition == value)
			{
				return;
			}
			this._horizontalScrollPosition = value;
			this.invalidate(INVALIDATION_FLAG_SCROLL);
		}

		private var _verticalScrollPosition:Number = 0;

		public function get verticalScrollPosition():Number
		{
			return this._verticalScrollPosition;
		}

		public function set verticalScrollPosition(value:Number):void
		{
			if(this._verticalScrollPosition == value)
			{
				return;
			}
			this._verticalScrollPosition = value;
			this.invalidate(INVALIDATION_FLAG_SCROLL);
		}

		public function get requiresMeasurementOnScroll():Boolean
		{
			return this._layout.requiresLayoutOnScroll &&
				(this._explicitVisibleWidth !== this._explicitVisibleWidth || //isNaN
				this._explicitVisibleHeight !== this._explicitVisibleHeight); //isNaN
		}

		private var _ignoreSelectionChanges:Boolean = false;

		private var _isSelectable:Boolean = true;

		public function get isSelectable():Boolean
		{
			return this._isSelectable;
		}

		public function set isSelectable(value:Boolean):void
		{
			if(this._isSelectable == value)
			{
				return;
			}
			this._isSelectable = value;
			if(!this._isSelectable)
			{
				this.selectedItem = null;
			}
			this.invalidate(INVALIDATION_FLAG_SELECTED);
		}

		private var _selectedItem:Object = null;

		public function get selectedItem():Object
		{
			return this._selectedItem;
		}

		public function set selectedItem(value:Object):void
		{
			if(this._selectedItem == value)
			{
				return;
			}
			this._selectedItem = value;
			this.invalidate(INVALIDATION_FLAG_SELECTED);
			this.dispatchEventWith(Event.CHANGE);
		}

		private var _typicalItem:Object = null;

		public function get typicalItem():Object
		{
			return this._typicalItem;
		}

		public function set typicalItem(value:Object):void
		{
			if(this._typicalItem == value)
			{
				return;
			}
			this._typicalItem = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		private var _itemRendererType:Class;

		public function get itemRendererType():Class
		{
			return this._itemRendererType;
		}

		public function set itemRendererType(value:Class):void
		{
			if(this._itemRendererType == value)
			{
				return;
			}

			this._itemRendererType = value;
			this.invalidate(INVALIDATION_FLAG_ITEM_RENDERER_FACTORY);
		}

		private var _itemRendererFactory:Function;

		public function get itemRendererFactory():Function
		{
			return this._itemRendererFactory;
		}

		public function set itemRendererFactory(value:Function):void
		{
			if(this._itemRendererFactory === value)
			{
				return;
			}

			this._itemRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_ITEM_RENDERER_FACTORY);
		}

		private var _itemRendererFactories:Object;

		public function get itemRendererFactories():Object
		{
			return this._itemRendererFactories;
		}

		public function set itemRendererFactories(value:Object):void
		{
			if(this._itemRendererFactories === value)
			{
				return;
			}

			this._itemRendererFactories = value;
			this.invalidate(INVALIDATION_FLAG_ITEM_RENDERER_FACTORY);
		}

		private var _factoryIDFunction:Function;

		public function get factoryIDFunction():Function
		{
			return this._factoryIDFunction;
		}

		public function set factoryIDFunction(value:Function):void
		{
			if(this._factoryIDFunction === value)
			{
				return;
			}

			this._factoryIDFunction = value;
			this.invalidate(INVALIDATION_FLAG_ITEM_RENDERER_FACTORY);
		}

		private var _customItemRendererStyleName:String;

		public function get customItemRendererStyleName():String
		{
			return this._customItemRendererStyleName;
		}

		public function set customItemRendererStyleName(value:String):void
		{
			if(this._customItemRendererStyleName == value)
			{
				return;
			}
			this._customItemRendererStyleName = value;
			this.invalidate(INVALIDATION_FLAG_ITEM_RENDERER_FACTORY);
		}

		private var _openBranches:IListCollection;

		public function get openBranches():IListCollection
		{
			return this._openBranches;
		}

		public function set openBranches(value:IListCollection):void
		{
			if(this._openBranches == value)
			{
				return;
			}
			if(this._openBranches !== null)
			{
				this._openBranches.removeEventListener(Event.CHANGE, openBranches_changeHandler);
			}
			this._openBranches = value;
			if(this._openBranches !== null)
			{
				this._openBranches.addEventListener(Event.CHANGE, openBranches_changeHandler);
			}
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		private var _typicalItemIsInDataProvider:Boolean = false;
		private var _typicalItemRenderer:ITreeItemRenderer;

		private var _layoutItems:Vector.<DisplayObject> = new <DisplayObject>[];

		private var _unrenderedItems:Array = [];
		private var _defaultItemRendererStorage:ItemRendererFactoryStorage = new ItemRendererFactoryStorage();
		private var _itemStorageMap:Object = {};
		private var _itemRendererMap:Dictionary = new Dictionary(true);
		private var _minimumItemCount:int;

		public function calculateNavigationDestination(location:Vector.<int>, keyCode:uint, result:Vector.<int>):void
		{
			var displayIndex:int = this.locationToDisplayIndex(location, false);
			if(displayIndex == -1)
			{
				throw new ArgumentError(""Cannot calculate navigation destination for location: "" + location);
			}
			var newDisplayIndex:int = this._layout.calculateNavigationDestination(this._layoutItems, displayIndex, keyCode, this._layoutResult);
			this.displayIndexToLocation(newDisplayIndex, result);
		}

		public function getScrollPositionForLocation(location:Vector.<int>, result:Point = null):Point
		{
			if(!result)
			{
				result = new Point();
			}

			var displayIndex:int = this.locationToDisplayIndex(location, true);
			if(displayIndex == -1)
			{
				throw new ArgumentError(""Cannot calculate scroll position for location: "" + location);
			}
			return this._layout.getScrollPositionForIndex(displayIndex, this._layoutItems,
				0, 0, this._actualVisibleWidth, this._actualVisibleHeight, result);
		}

		public function getNearestScrollPositionForIndex(location:Vector.<int>, result:Point = null):Point
		{
			if(!result)
			{
				result = new Point();
			}

			var displayIndex:int = this.locationToDisplayIndex(location, true);
			if(displayIndex == -1)
			{
				throw new ArgumentError(""Cannot calculate nearest scroll position for location: "" + location);
			}
			return this._layout.getNearestScrollPositionForIndex(displayIndex, this._horizontalScrollPosition,
				this._verticalScrollPosition, this._layoutItems, 0, 0, this._actualVisibleWidth, this._actualVisibleHeight, result);
		}

		public function itemToItemRenderer(item:Object):ITreeItemRenderer
		{
			if(item is XML || item is XMLList)
			{
				return ITreeItemRenderer(this._itemRendererMap[item.toXMLString()]);
			}
			return ITreeItemRenderer(this._itemRendererMap[item]);
		}

		override public function dispose():void
		{
			this.refreshInactiveItemRenderers(null, true);
			if(this._itemStorageMap)
			{
				for(var factoryID:String in this._itemStorageMap)
				{
					this.refreshInactiveItemRenderers(factoryID, true);
				}
			}
			this.owner = null;
			this.dataProvider = null;
			this.layout = null;
			super.dispose();
		}

		override protected function draw():void
		{
			var dataInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_DATA);
			var scrollInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SCROLL);
			var sizeInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SIZE);
			var selectionInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SELECTED);
			var itemRendererInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_ITEM_RENDERER_FACTORY);
			var stylesInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STYLES);
			var stateInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STATE);
			var layoutInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_LAYOUT);

			//scrolling only affects the layout is requiresLayoutOnScroll is true
			if(!layoutInvalid && scrollInvalid && this._layout && this._layout.requiresLayoutOnScroll)
			{
				layoutInvalid = true;
			}

			var basicsInvalid:Boolean = sizeInvalid || dataInvalid || layoutInvalid || itemRendererInvalid;

			var oldIgnoreRendererResizing:Boolean = this._ignoreRendererResizing;
			this._ignoreRendererResizing = true;
			var oldIgnoreLayoutChanges:Boolean = this._ignoreLayoutChanges;
			this._ignoreLayoutChanges = true;

			if(scrollInvalid || sizeInvalid)
			{
				this.refreshViewPortBounds();
			}
			if(basicsInvalid)
			{
				this.refreshInactiveItemRenderers(null, itemRendererInvalid);
				if(this._itemStorageMap)
				{
					for(var factoryID:String in this._itemStorageMap)
					{
						this.refreshInactiveItemRenderers(factoryID, itemRendererInvalid);
					}
				}
			}
			if(dataInvalid || layoutInvalid || itemRendererInvalid)
			{
				this.refreshLayoutTypicalItem();
			}
			if(basicsInvalid)
			{
				this.refreshItemRenderers();
			}
			if(selectionInvalid || basicsInvalid)
			{
				//unlike resizing renderers and layout changes, we only want to
				//stop listening for selection changes when we're forcibly
				//updating selection. other property changes on item renderers
				//can validly change selection, and we need to detect that.
				var oldIgnoreSelectionChanges:Boolean = this._ignoreSelectionChanges;
				this._ignoreSelectionChanges = true;
				this.refreshSelection();
				this._ignoreSelectionChanges = oldIgnoreSelectionChanges;
			}
			if(stateInvalid || basicsInvalid)
			{
				this.refreshEnabled();
			}
			this._ignoreLayoutChanges = oldIgnoreLayoutChanges;

			if(stateInvalid || selectionInvalid || stylesInvalid || basicsInvalid)
			{
				this._layout.layout(this._layoutItems, this._viewPortBounds, this._layoutResult);
			}

			this._ignoreRendererResizing = oldIgnoreRendererResizing;

			this._contentX = this._layoutResult.contentX;
			this._contentY = this._layoutResult.contentY;
			this.saveMeasurements(this._layoutResult.contentWidth, this._layoutResult.contentHeight,
				this._layoutResult.contentWidth, this._layoutResult.contentHeight);
			this._actualVisibleWidth = this._layoutResult.viewPortWidth;
			this._actualVisibleHeight = this._layoutResult.viewPortHeight;
			this._actualMinVisibleWidth = this._layoutResult.viewPortWidth;
			this._actualMinVisibleHeight = this._layoutResult.viewPortHeight;

			//final validation to avoid juggler next frame issues
			this.validateRenderers();
		}

		private function displayIndexToLocation(displayIndex:int, result:Vector.<int>):void
		{
		}

		private var _displayIndex:int;

		private function locationToDisplayIndex(location:Vector.<int>, returnNearestIfBranchNotOpen:Boolean):int
		{
			this._displayIndex = -1;
			var result:Object = this.locationToDisplayIndexAtBranch(new <int>[], location, returnNearestIfBranchNotOpen);
			if(result !== null)
			{
				return this._displayIndex;
			}
			return -1;
		}

		private function locationToDisplayIndexAtBranch(locationOfBranch:Vector.<int>, locationToFind:Vector.<int>, returnNearestIfBranchNotOpen:Boolean):Object
		{
			var childCount:int = this._dataProvider.getLengthAtLocation(locationOfBranch);
			for(var i:int = 0; i < childCount; i++)
			{
				this._displayIndex++;
				locationOfBranch[locationOfBranch.length] = i;
				var child:Object = this._dataProvider.getItemAtLocation(locationOfBranch);
				if(locationOfBranch.length == locationToFind.length)
				{
					var every:Boolean = locationOfBranch.every(function(item:int, index:int, source:Vector.<int>):Boolean
					{
						return item === locationToFind[index];
					});
					if(every)
					{
						return child;
					}
				}
				if(this._dataProvider.isBranch(child))
				{
					if(this.owner.isBranchOpen(child))
					{
						var result:Object = this.locationToDisplayIndexAtBranch(locationOfBranch, locationToFind, returnNearestIfBranchNotOpen);
						if(result)
						{
							return result;
						}
					}
					else if(returnNearestIfBranchNotOpen)
					{
						//if the location is inside a closed branch
						//return that branch
						every = locationOfBranch.every(function(item:int, index:int, source:Vector.<int>):Boolean
						{
							return item === locationToFind[index];
						});
						if(every)
						{
							return child;
						}
					}
				}
				locationOfBranch.length--;
			}
			//location was not found!
			return null;
		}

		private function refreshViewPortBounds():void
		{
			var needsMinWidth:Boolean = this._explicitMinVisibleWidth !== this._explicitMinVisibleWidth; //isNaN
			var needsMinHeight:Boolean = this._explicitMinVisibleHeight !== this._explicitMinVisibleHeight; //isNaN
			this._viewPortBounds.x = 0;
			this._viewPortBounds.y = 0;
			this._viewPortBounds.scrollX = this._horizontalScrollPosition;
			this._viewPortBounds.scrollY = this._verticalScrollPosition;
			this._viewPortBounds.explicitWidth = this._explicitVisibleWidth;
			this._viewPortBounds.explicitHeight = this._explicitVisibleHeight;
			if(needsMinWidth)
			{
				this._viewPortBounds.minWidth = 0;
			}
			else
			{
				this._viewPortBounds.minWidth = this._explicitMinVisibleWidth;
			}
			if(needsMinHeight)
			{
				this._viewPortBounds.minHeight = 0;
			}
			else
			{
				this._viewPortBounds.minHeight = this._explicitMinVisibleHeight;
			}
			this._viewPortBounds.maxWidth = this._maxVisibleWidth;
			this._viewPortBounds.maxHeight = this._maxVisibleHeight;
		}

		private function refreshLayoutTypicalItem():void
		{
			var virtualLayout:IVirtualLayout = this._layout as IVirtualLayout;
			if(virtualLayout === null || !virtualLayout.useVirtualLayout)
			{
				//the old layout was virtual, but this one isn't
				if(!this._typicalItemIsInDataProvider && this._typicalItemRenderer !== null)
				{
					//it's safe to destroy this renderer
					this.destroyItemRenderer(this._typicalItemRenderer);
					this._typicalItemRenderer = null;
				}
				return;
			}
			var typicalItemLocation:Vector.<int> = null;
			var newTypicalItemIsInDataProvider:Boolean = false;
			var typicalItem:Object = this._typicalItem;
			if(typicalItem !== null)
			{
				if(this._dataProvider !== null)
				{
					typicalItemLocation = this._dataProvider.getItemLocation(typicalItem);
					newTypicalItemIsInDataProvider = typicalItemLocation !== null && typicalItemLocation.length > 0;
				}
			}
			else
			{
				if(this._dataProvider !== null && this._dataProvider.getLengthAtLocation() > 0)
				{
					newTypicalItemIsInDataProvider = true;
					typicalItem = this._dataProvider.getItemAt(0);
					typicalItemLocation = new <int>[0];
				}
			}

			//#1645 The typicalItem can be null if the data provider contains
			//a null value at index 0. this is the only time we allow null.
			if(typicalItem !== null || newTypicalItemIsInDataProvider)
			{
				var typicalItemRenderer:ITreeItemRenderer = this.itemToItemRenderer(typicalItem);
				if(typicalItemRenderer !== null)
				{
					//at this point, the item already has an item renderer.
					//(this doesn't necessarily mean that the current typical
					//item was the typical item last time this function was
					//called)

					//the location may have changed if items were added,
					//removed or reordered in the data provider
					typicalItemRenderer.location = typicalItemLocation;
				}
				if(typicalItemRenderer === null && this._typicalItemRenderer !== null)
				{
					//the typical item has changed, and doesn't have an item
					//renderer yet. the previous typical item had an item
					//renderer, so we will try to reuse it.

					//we can reuse the existing typical item renderer if the old
					//typical item wasn't in the data provider. otherwise, it
					//may still be needed for the same item.
					var canReuse:Boolean = !this._typicalItemIsInDataProvider;
					var oldTypicalItemRemoved:Boolean = this._typicalItemIsInDataProvider &&
						this._dataProvider !== null && this._dataProvider.getItemLocation(this._typicalItemRenderer.data) === null;
					if(!canReuse && oldTypicalItemRemoved)
					{
						//special case: if the old typical item was in the data
						//provider, but it has been removed, it's safe to reuse.
						canReuse = true;
					}
					if(canReuse)
					{
						//we can't reuse if the factoryID has changed, though!
						var factoryID:String = null;
						if(this._factoryIDFunction !== null)
						{
							factoryID = this.getFactoryID(typicalItem, typicalItemLocation);
						}
						if(this._typicalItemRenderer.factoryID !== factoryID)
						{
							canReuse = false;
						}
					}
					if(canReuse)
					{
						//we can reuse the item renderer used for the old
						//typical item!

						//if the old typical item was in the data provider,
						//remove it from the renderer map.
						if(this._typicalItemIsInDataProvider)
						{
							var oldData:Object = this._typicalItemRenderer.data;
							if(oldData is XML || oldData is XMLList)
							{
								delete this._itemRendererMap[oldData.toXMLString()];
							}
							else
							{
								delete this._itemRendererMap[oldData];
							}
						}
						typicalItemRenderer = this._typicalItemRenderer;
						typicalItemRenderer.data = typicalItem;
						typicalItemRenderer.location = typicalItemLocation;
						//if the new typical item is in the data provider, add it
						//to the renderer map.
						if(newTypicalItemIsInDataProvider)
						{
							if(typicalItem is XML || typicalItem is XMLList)
							{
								this._itemRendererMap[typicalItem.toXMLString()] = typicalItemRenderer;
							}
							else
							{
								this._itemRendererMap[typicalItem] = typicalItemRenderer;
							}
						}
					}
				}
				if(typicalItemRenderer === null)
				{
					//if we still don't have a typical item renderer, we need to
					//create a new one.
					typicalItemRenderer = this.createItemRenderer(typicalItem, typicalItemLocation, 0, false, !newTypicalItemIsInDataProvider);
					if(!this._typicalItemIsInDataProvider && this._typicalItemRenderer !== null)
					{
						//get rid of the old typical item renderer if it isn't
						//needed anymore.  since it was not in the data
						//provider, we don't need to mess with the renderer map
						//dictionary or dispatch any events.
						this.destroyItemRenderer(this._typicalItemRenderer);
						this._typicalItemRenderer = null;
					}
				}
			}

			virtualLayout.typicalItem = DisplayObject(typicalItemRenderer);
			this._typicalItemRenderer = typicalItemRenderer;
			this._typicalItemIsInDataProvider = newTypicalItemIsInDataProvider;
			if(this._typicalItemRenderer !== null && !this._typicalItemIsInDataProvider)
			{
				//we need to know if this item renderer resizes to adjust the
				//layout because the layout may use this item renderer to resize
				//the other item renderers
				this._typicalItemRenderer.addEventListener(FeathersEventType.RESIZE, itemRenderer_resizeHandler);
			}
		}

		private function refreshItemRenderers():void
		{
			if(this._typicalItemRenderer !== null && this._typicalItemIsInDataProvider)
			{
				var storage:ItemRendererFactoryStorage = this.factoryIDToStorage(this._typicalItemRenderer.factoryID);
				var inactiveItemRenderers:Vector.<ITreeItemRenderer> = storage.inactiveItemRenderers;
				var activeItemRenderers:Vector.<ITreeItemRenderer> = storage.activeItemRenderers;
				//this renderer is already is use by the typical item, so we
				//don't want to allow it to be used by other items.
				var inactiveIndex:int = inactiveItemRenderers.indexOf(this._typicalItemRenderer);
				if(inactiveIndex >= 0)
				{
					inactiveItemRenderers[inactiveIndex] = null;
				}
				//if refreshLayoutTypicalItem() was called, it will have already
				//added the typical item renderer to the active renderers. if
				//not, we need to do it here.
				var activeRendererCount:int = activeItemRenderers.length;
				if(activeRendererCount == 0)
				{
					activeItemRenderers[activeRendererCount] = this._typicalItemRenderer;
				}
			}

			this.findUnrenderedData();
			this.recoverInactiveItemRenderers(this._defaultItemRendererStorage);
			if(this._itemStorageMap)
			{
				for(var factoryID:String in this._itemStorageMap)
				{
					storage = ItemRendererFactoryStorage(this._itemStorageMap[factoryID]);
					this.recoverInactiveItemRenderers(storage);
				}
			}
			this.renderUnrenderedData();
			this.freeInactiveItemRenderers(this._defaultItemRendererStorage, this._minimumItemCount);
			if(this._itemStorageMap)
			{
				for(factoryID in this._itemStorageMap)
				{
					storage = ItemRendererFactoryStorage(this._itemStorageMap[factoryID]);
					this.freeInactiveItemRenderers(storage, 1);
				}
			}
			this._updateForDataReset = false;
		}

		private function findTotalLayoutCount(location:Vector.<int>):int
		{
			var itemCount:int = 0;
			if(this._dataProvider !== null)
			{
				itemCount = this._dataProvider.getLengthAtLocation(location);
			}
			var result:int = itemCount;
			for(var i:int = 0; i < itemCount; i++)
			{
				location[location.length] = i;
				var item:Object = this._dataProvider.getItemAtLocation(location);
				if(this._dataProvider.isBranch(item) &&
					this._openBranches.contains(item))
				{
					result += this.findTotalLayoutCount(location);
				}
				location.length--;
			}
			return result;
		}

		private function findUnrenderedDataForLocation(location:Vector.<int>, currentIndex:int):int
		{
			var virtualLayout:IVirtualLayout = this._layout as IVirtualLayout;
			var useVirtualLayout:Boolean = virtualLayout !== null && virtualLayout.useVirtualLayout;
			var itemCount:int = 0;
			if(this._dataProvider !== null)
			{
				itemCount = this._dataProvider.getLengthAtLocation(location);
			}
			for(var i:int = 0; i < itemCount; i++)
			{
				location[location.length] = i;
				var item:Object = this._dataProvider.getItemAtLocation(location);

				if(useVirtualLayout && HELPER_VECTOR.indexOf(currentIndex) == -1)
				{
					if(this._typicalItemRenderer !== null &&
						this._typicalItemIsInDataProvider &&
						this._typicalItemRenderer.data === item)
					{
						//the index may have changed if items were added, removed,
						//or reordered in the data provider
						this._typicalItemRenderer.layoutIndex = currentIndex;
					}
					this._layoutItems[currentIndex] = null;
				}
				else
				{
					this.findRendererForItem(item, location.slice(), currentIndex);
				}
				currentIndex++;

				if(this._dataProvider.isBranch(item) &&
					this._openBranches.contains(item))
				{
					currentIndex = this.findUnrenderedDataForLocation(location, currentIndex);
				}
				location.length--;
			}
			return currentIndex;
		}

		private function findUnrenderedData():void
		{
			LOCATION_HELPER_VECTOR.length = 0;
			var totalLayoutCount:int = this.findTotalLayoutCount(LOCATION_HELPER_VECTOR);
			LOCATION_HELPER_VECTOR.length = 0;
			this._layoutItems.length = totalLayoutCount;
			var virtualLayout:IVirtualLayout = this._layout as IVirtualLayout;
			var useVirtualLayout:Boolean = virtualLayout !== null && virtualLayout.useVirtualLayout;
			if(useVirtualLayout)
			{
				var point:Point = Pool.getPoint();
				virtualLayout.measureViewPort(totalLayoutCount, this._viewPortBounds, point);
				var viewPortWidth:Number = point.x;
				var viewPortHeight:Number = point.y;
				Pool.putPoint(point);
				virtualLayout.getVisibleIndicesAtScrollPosition(this._horizontalScrollPosition, this._verticalScrollPosition, viewPortWidth, viewPortHeight, totalLayoutCount, HELPER_VECTOR);

				if(this._typicalItemRenderer !== null)
				{
					var minimumTypicalItemEdge:Number = this._typicalItemRenderer.height;
					if(this._typicalItemRenderer.width < minimumTypicalItemEdge)
					{
						minimumTypicalItemEdge = this._typicalItemRenderer.width;
					}

					var maximumViewPortEdge:Number = viewPortWidth;
					if(viewPortHeight > viewPortWidth)
					{
						maximumViewPortEdge = viewPortHeight;
					}

					this._minimumItemCount = Math.ceil(maximumViewPortEdge / minimumTypicalItemEdge) + 1;
				}
				else
				{
					this._minimumItemCount = 1;
				}
			}
			LOCATION_HELPER_VECTOR.length = 0;
			this.findUnrenderedDataForLocation(LOCATION_HELPER_VECTOR, 0);
			LOCATION_HELPER_VECTOR.length = 0;
			//update the typical item renderer's visibility
			if(this._typicalItemRenderer !== null)
			{
				if(useVirtualLayout && this._typicalItemIsInDataProvider)
				{
					var index:int = HELPER_VECTOR.indexOf(this._typicalItemRenderer.layoutIndex);
					if(index >= 0)
					{
						this._typicalItemRenderer.visible = true;
					}
					else
					{
						this._typicalItemRenderer.visible = false;

						//uncomment these lines to see a hidden typical item for
						//debugging purposes...
						/*this._typicalItemRenderer.visible = true;
						this._typicalItemRenderer.x = this._horizontalScrollPosition;
						this._typicalItemRenderer.y = this._verticalScrollPosition;*/
					}
				}
				else
				{
					this._typicalItemRenderer.visible = this._typicalItemIsInDataProvider;
				}
			}
			HELPER_VECTOR.length = 0;
		}

		private function findRendererForItem(item:Object, location:Vector.<int>, layoutIndex:int):void
		{
			var itemRenderer:ITreeItemRenderer = this.itemToItemRenderer(item);
			if(this._factoryIDFunction !== null && itemRenderer !== null)
			{
				var newFactoryID:String = this.getFactoryID(itemRenderer.data, location);
				if(newFactoryID !== itemRenderer.factoryID)
				{
					itemRenderer = null;
					if(item is XML || item is XMLList)
					{
						delete this._itemRendererMap[item.toXMLString()];
					}
					else
					{
						delete this._itemRendererMap[item];
					}
				}
			}
			if(itemRenderer !== null)
			{
				//the indices may have changed if items were added, removed,
				//or reordered in the data provider
				itemRenderer.location = location;
				itemRenderer.layoutIndex = layoutIndex;
				itemRenderer.isOpen = this._dataProvider.isBranch(item) && this._openBranches.contains(item);
				if(this._updateForDataReset)
				{
					//similar to calling updateItemAt(), replacing the data
					//provider or resetting its source means that we should
					//trick the item renderer into thinking it has new data.
					//many developers seem to expect this behavior, so while
					//it's not the most optimal for performance, it saves on
					//support time in the forums. thankfully, it's still
					//somewhat optimized since the same item renderer will
					//receive the same data, and the children generally
					//won't have changed much, if at all.
					itemRenderer.data = null;
					itemRenderer.data = item;
				}

				//the typical item renderer is a special case, and we will
				//have already put it into the active renderers, so we don't
				//want to do it again!
				if(this._typicalItemRenderer !== itemRenderer)
				{
					var storage:ItemRendererFactoryStorage = this.factoryIDToStorage(itemRenderer.factoryID);
					var activeItemRenderers:Vector.<ITreeItemRenderer> = storage.activeItemRenderers;
					var inactiveItemRenderers:Vector.<ITreeItemRenderer> = storage.inactiveItemRenderers;
					activeItemRenderers[activeItemRenderers.length] = itemRenderer;
					var inactiveIndex:int = inactiveItemRenderers.indexOf(itemRenderer);
					if(inactiveIndex >= 0)
					{
						inactiveItemRenderers.removeAt(inactiveIndex);
					}
					else
					{
						throw new IllegalOperationError(""TreeDataViewPort: item renderer map contains bad data. This may be caused by duplicate items in the data provider, which is not allowed."");
					}
				}
				itemRenderer.visible = true;
				this._layoutItems[layoutIndex] = DisplayObject(itemRenderer);
			}
			else
			{
				var pushIndex:int = this._unrenderedItems.length;
				this._unrenderedItems[pushIndex] = location;
				pushIndex++;
				this._unrenderedItems[pushIndex] = layoutIndex;
			}
		}

		private function renderUnrenderedData():void
		{
			LOCATION_HELPER_VECTOR.length = 2;
			var rendererCount:int = this._unrenderedItems.length;
			for(var i:int = 0; i < rendererCount; i += 2)
			{
				var location:Vector.<int> = this._unrenderedItems.shift();
				var layoutIndex:int = this._unrenderedItems.shift();
				var item:Object = this._dataProvider.getItemAtLocation(location);
				var itemRenderer:ITreeItemRenderer = this.createItemRenderer(
					item, location, layoutIndex, true, false);
				itemRenderer.visible = true;
				this._layoutItems[layoutIndex] = DisplayObject(itemRenderer);
			}
			LOCATION_HELPER_VECTOR.length = 0;
		}

		private function refreshInactiveItemRenderers(factoryID:String, itemRendererTypeIsInvalid:Boolean):void
		{
			if(factoryID !== null)
			{
				var storage:ItemRendererFactoryStorage = ItemRendererFactoryStorage(this._itemStorageMap[factoryID]);
			}
			else
			{
				storage = this._defaultItemRendererStorage;
			}
			var temp:Vector.<ITreeItemRenderer> = storage.inactiveItemRenderers;
			storage.inactiveItemRenderers = storage.activeItemRenderers;
			storage.activeItemRenderers = temp;
			if(storage.activeItemRenderers.length > 0)
			{
				throw new IllegalOperationError(""TreeDataViewPort: active renderers should be empty."");
			}
			if(itemRendererTypeIsInvalid)
			{
				this.recoverInactiveItemRenderers(storage);
				this.freeInactiveItemRenderers(storage, 0);
				if(this._typicalItemRenderer && this._typicalItemRenderer.factoryID === factoryID)
				{
					if(this._typicalItemIsInDataProvider)
					{
						var item:Object = this._typicalItemRenderer.data;
						if(item is XML || item is XMLList)
						{
							delete this._itemRendererMap[item.toXMLString()];
						}
						else
						{
							delete this._itemRendererMap[item];
						}
					}
					this.destroyItemRenderer(this._typicalItemRenderer);
					this._typicalItemRenderer = null;
					this._typicalItemIsInDataProvider = false;
				}
			}

			this._layoutItems.length = 0;
		}

		private function recoverInactiveItemRenderers(storage:ItemRendererFactoryStorage):void
		{
			var inactiveItemRenderers:Vector.<ITreeItemRenderer> = storage.inactiveItemRenderers;

			var itemCount:int = inactiveItemRenderers.length;
			for(var i:int = 0; i < itemCount; i++)
			{
				var itemRenderer:ITreeItemRenderer = inactiveItemRenderers[i];
				if(itemRenderer === null || itemRenderer.data === null)
				{
					continue;
				}
				this._owner.dispatchEventWith(FeathersEventType.RENDERER_REMOVE, false, itemRenderer);
				var item:Object = itemRenderer.data;
				if(item is XML || item is XMLList)
				{
					delete this._itemRendererMap[item.toXMLString()];
				}
				else
				{
					delete this._itemRendererMap[item];
				}
			}
		}

		private function freeInactiveItemRenderers(storage:ItemRendererFactoryStorage, minimumItemCount:int):void
		{
			var inactiveItemRenderers:Vector.<ITreeItemRenderer> = storage.inactiveItemRenderers;
			var activeItemRenderers:Vector.<ITreeItemRenderer> = storage.activeItemRenderers;
			var activeItemRenderersCount:int = activeItemRenderers.length;

			//we may keep around some extra renderers to avoid too much
			//allocation and garbage collection. they'll be hidden.
			var itemCount:int = inactiveItemRenderers.length;
			var keepCount:int = minimumItemCount - activeItemRenderersCount;
			if(keepCount > itemCount)
			{
				keepCount = itemCount;
			}
			for(var i:int = 0; i < keepCount; i++)
			{
				var itemRenderer:ITreeItemRenderer = inactiveItemRenderers.shift();
				if(!itemRenderer)
				{
					keepCount++;
					if(itemCount < keepCount)
					{
						keepCount = itemCount;
					}
					continue;
				}
				itemRenderer.data = null;
				itemRenderer.location = null;
				itemRenderer.visible = false;
				activeItemRenderers[activeItemRenderersCount] = itemRenderer;
				activeItemRenderersCount++;
			}
			itemCount -= keepCount;
			for(i = 0; i < itemCount; i++)
			{
				itemRenderer = inactiveItemRenderers.shift();
				if(!itemRenderer)
				{
					continue;
				}
				this.destroyItemRenderer(itemRenderer);
			}
		}

		private function createItemRenderer(item:Object, location:Vector.<int>, layoutIndex:int, useCache:Boolean, isTemporary:Boolean):ITreeItemRenderer
		{
			var factoryID:String = null;
			if(this._factoryIDFunction !== null)
			{
				factoryID = this.getFactoryID(item, location);
			}
			var itemRendererFactory:Function = this.factoryIDToFactory(factoryID);
			var storage:ItemRendererFactoryStorage = this.factoryIDToStorage(factoryID);
			var inactiveItemRenderers:Vector.<ITreeItemRenderer> = storage.inactiveItemRenderers;
			var activeItemRenderers:Vector.<ITreeItemRenderer> = storage.activeItemRenderers;
			var itemRenderer:ITreeItemRenderer;
			do
			{
				if(!useCache || isTemporary || inactiveItemRenderers.length == 0)
				{
					if(itemRendererFactory !== null)
					{
						itemRenderer = ITreeItemRenderer(itemRendererFactory());
					}
					else
					{
						itemRenderer = ITreeItemRenderer(new this._itemRendererType());
					}
					if(this._customItemRendererStyleName && this._customItemRendererStyleName.length > 0)
					{
						itemRenderer.styleNameList.add(this._customItemRendererStyleName);
					}
					this.addChild(DisplayObject(itemRenderer));
				}
				else
				{
					itemRenderer = inactiveItemRenderers.shift();
				}
				//wondering why this all is in a loop?
				//_inactiveRenderers.shift() may return null because we're
				//storing null values instead of calling splice() to improve
				//performance.
			}
			while(!itemRenderer);
			itemRenderer.data = item;
			itemRenderer.owner = this._owner;
			itemRenderer.factoryID = factoryID;
			itemRenderer.location = location;
			itemRenderer.layoutIndex = layoutIndex;
			var isBranch:Boolean = this._dataProvider !== null && this._dataProvider.isBranch(item);
			itemRenderer.isBranch = isBranch;
			itemRenderer.isOpen = isBranch && this._openBranches.contains(item);

			if(!isTemporary)
			{
				if(item is XML || item is XMLList)
				{
					this._itemRendererMap[item.toXMLString()] = itemRenderer;
				}
				else
				{
					this._itemRendererMap[item] = itemRenderer;
				}
				activeItemRenderers[activeItemRenderers.length] = itemRenderer;
				itemRenderer.addEventListener(Event.TRIGGERED, itemRenderer_triggeredHandler);
				itemRenderer.addEventListener(Event.CHANGE, itemRenderer_changeHandler);
				itemRenderer.addEventListener(FeathersEventType.RESIZE, itemRenderer_resizeHandler);
				this._owner.dispatchEventWith(FeathersEventType.RENDERER_ADD, false, itemRenderer);
			}

			return itemRenderer;
		}

		private function destroyItemRenderer(itemRenderer:ITreeItemRenderer):void
		{
			itemRenderer.removeEventListener(Event.TRIGGERED, itemRenderer_triggeredHandler);
			itemRenderer.removeEventListener(Event.CHANGE, itemRenderer_changeHandler);
			itemRenderer.removeEventListener(FeathersEventType.RESIZE, itemRenderer_resizeHandler);
			itemRenderer.owner = null;
			itemRenderer.data = null;
			itemRenderer.location = null;
			itemRenderer.layoutIndex = -1;
			itemRenderer.factoryID = null;
			this.removeChild(DisplayObject(itemRenderer), true);
		}

		private function getFactoryID(item:Object, location:Vector.<int>):String
		{
			if(this._factoryIDFunction === null)
			{
				return null;
			}
			if(this._factoryIDFunction.length == 2)
			{
				return this._factoryIDFunction(item, location);
			}
			return this._factoryIDFunction(item);
		}

		private function factoryIDToFactory(id:String):Function
		{
			if(id !== null)
			{
				if(id in this._itemRendererFactories)
				{
					return this._itemRendererFactories[id] as Function;
				}
				else
				{
					throw new ReferenceError(""Cannot find item renderer factory for ID \\"""" + id + ""\\""."");
				}
			}
			return this._itemRendererFactory;
		}

		private function factoryIDToStorage(id:String):ItemRendererFactoryStorage
		{
			if(id !== null)
			{
				if(id in this._itemStorageMap)
				{
					return ItemRendererFactoryStorage(this._itemStorageMap[id]);
				}
				var storage:ItemRendererFactoryStorage = new ItemRendererFactoryStorage();
				this._itemStorageMap[id] = storage;
				return storage;
			}
			return this._defaultItemRendererStorage;
		}

		private function invalidateParent(flag:String = INVALIDATION_FLAG_ALL):void
		{
			Scroller(this.parent).invalidate(flag);
		}

		private function refreshSelection():void
		{
			for each(var item:DisplayObject in this._layoutItems)
			{
				var itemRenderer:ITreeItemRenderer = item as ITreeItemRenderer;
				if(itemRenderer !== null)
				{
					itemRenderer.isSelected = itemRenderer.data === this._selectedItem;
				}
			}
		}

		private function refreshEnabled():void
		{
			for each(var item:DisplayObject in this._layoutItems)
			{
				var control:IFeathersControl = item as IFeathersControl;
				if(control !== null)
				{
					control.isEnabled = this._isEnabled;
				}
			}
		}

		private function validateRenderers():void
		{
			var itemCount:int = this._layoutItems.length;
			for(var i:int = 0; i < itemCount; i++)
			{
				var item:IValidating = this._layoutItems[i] as IValidating;
				if(item !== null)
				{
					item.validate();
				}
			}
		}

		private function layout_changeHandler(event:Event):void
		{
			if(this._ignoreLayoutChanges)
			{
				return;
			}
			this.invalidate(INVALIDATION_FLAG_LAYOUT);
			this.invalidateParent(INVALIDATION_FLAG_LAYOUT);
		}

		private function dataProvider_changeHandler(event:Event):void
		{
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		private function itemRenderer_triggeredHandler(event:Event):void
		{
			var itemRenderer:ITreeItemRenderer = ITreeItemRenderer(event.currentTarget);
			this.parent.dispatchEventWith(Event.TRIGGERED, false, itemRenderer.data);
		}

		private function itemRenderer_changeHandler(event:Event):void
		{
			if(this._ignoreSelectionChanges)
			{
				return;
			}
			var itemRenderer:ITreeItemRenderer = ITreeItemRenderer(event.currentTarget);
			if(!this._isSelectable || this._owner.isScrolling)
			{
				itemRenderer.isSelected = false;
				return;
			}
			var isSelected:Boolean = itemRenderer.isSelected;
			if(isSelected)
			{
				this.selectedItem = itemRenderer.data;
			}
			else
			{
				this.selectedItem = null;
			}
		}

		private function itemRenderer_resizeHandler(event:Event):void
		{
			if(this._ignoreRendererResizing)
			{
				return;
			}
			this.invalidate(INVALIDATION_FLAG_LAYOUT);
			this.invalidateParent(INVALIDATION_FLAG_LAYOUT);
			if(event.currentTarget === this._typicalItemRenderer && !this._typicalItemIsInDataProvider)
			{
				return;
			}
			var layout:IVariableVirtualLayout = this._layout as IVariableVirtualLayout;
			if(!layout || !layout.hasVariableItemDimensions)
			{
				return;
			}
			var itemRenderer:ITreeItemRenderer = ITreeItemRenderer(event.currentTarget);
			layout.resetVariableVirtualCacheAtIndex(itemRenderer.layoutIndex, DisplayObject(itemRenderer));
		}

		private function openBranches_changeHandler(event:Event):void
		{
			this.invalidate(INVALIDATION_FLAG_DATA);
		}
	}
}

import feathers.controls.renderers.ITreeItemRenderer;

class ItemRendererFactoryStorage
{
	public function ItemRendererFactoryStorage()
	{

	}

	public var activeItemRenderers:Vector.<ITreeItemRenderer> = new <ITreeItemRenderer>[];
	public var inactiveItemRenderers:Vector.<ITreeItemRenderer> = new <ITreeItemRenderer>[];
}",12482,False,2474.0642790540774,median
"UIElement@ browserWindow;
Window@ browserFilterWindow;
ListView@ browserDirList;
ListView@ browserFileList;
LineEdit@ browserSearch;
BrowserFile@ browserDragFile;
Node@ browserDragNode;
Component@ browserDragComponent;
View3D@ resourceBrowserPreview;
Scene@ resourcePreviewScene;
Node@ resourcePreviewNode;
Node@ resourcePreviewCameraNode;
Node@ resourcePreviewLightNode;
Light@ resourcePreviewLight;
int browserSearchSortMode = 0;

BrowserDir@ rootDir;
Array<BrowserFile@> browserFiles;
Dictionary browserDirs;
Array<int> activeResourceTypeFilters;
Array<int> activeResourceDirFilters;

Array<BrowserFile@> browserFilesToScan;
const uint BROWSER_WORKER_ITEMS_PER_TICK = 10;
const uint BROWSER_SEARCH_LIMIT = 50;
const int BROWSER_SORT_MODE_ALPHA = 1;
const int BROWSER_SORT_MODE_SEARCH = 2;

const int RESOURCE_TYPE_UNUSABLE = -2;
const int RESOURCE_TYPE_UNKNOWN = -1;
const int RESOURCE_TYPE_NOTSET = 0;
const int RESOURCE_TYPE_SCENE = 1;
const int RESOURCE_TYPE_SCRIPTFILE = 2;
const int RESOURCE_TYPE_MODEL = 3;
const int RESOURCE_TYPE_MATERIAL = 4;
const int RESOURCE_TYPE_ANIMATION = 5;
const int RESOURCE_TYPE_IMAGE = 6;
const int RESOURCE_TYPE_SOUND = 7;
const int RESOURCE_TYPE_TEXTURE = 8;
const int RESOURCE_TYPE_FONT = 9;
const int RESOURCE_TYPE_PREFAB = 10;
const int RESOURCE_TYPE_TECHNIQUE = 11;
const int RESOURCE_TYPE_PARTICLEEFFECT = 12;
const int RESOURCE_TYPE_UIELEMENT = 13;
const int RESOURCE_TYPE_UIELEMENTS = 14;
const int RESOURCE_TYPE_ANIMATION_SETTINGS = 15;
const int RESOURCE_TYPE_RENDERPATH = 16;
const int RESOURCE_TYPE_TEXTURE_ATLAS = 17;
const int RESOURCE_TYPE_2D_PARTICLE_EFFECT = 18;
const int RESOURCE_TYPE_TEXTURE_3D = 19;
const int RESOURCE_TYPE_CUBEMAP = 20;
const int RESOURCE_TYPE_PARTICLEEMITTER = 21;
const int RESOURCE_TYPE_2D_ANIMATION_SET = 22;

// any resource type > 0 is valid
const int NUMBER_OF_VALID_RESOURCE_TYPES = 22;

const StringHash XML_TYPE_SCENE(""scene"");
const StringHash XML_TYPE_NODE(""node"");
const StringHash XML_TYPE_MATERIAL(""material"");
const StringHash XML_TYPE_TECHNIQUE(""technique"");
const StringHash XML_TYPE_PARTICLEEFFECT(""particleeffect"");
const StringHash XML_TYPE_PARTICLEEMITTER(""particleemitter"");
const StringHash XML_TYPE_TEXTURE(""texture"");
const StringHash XML_TYPE_ELEMENT(""element"");
const StringHash XML_TYPE_ELEMENTS(""elements"");
const StringHash XML_TYPE_ANIMATION_SETTINGS(""animation"");
const StringHash XML_TYPE_RENDERPATH(""renderpath"");
const StringHash XML_TYPE_TEXTURE_ATLAS(""TextureAtlas"");
const StringHash XML_TYPE_2D_PARTICLE_EFFECT(""particleEmitterConfig"");
const StringHash XML_TYPE_TEXTURE_3D(""texture3d"");
const StringHash XML_TYPE_CUBEMAP(""cubemap"");
const StringHash XML_TYPE_SPRITER_DATA(""spriter_data"");

const StringHash JSON_TYPE_SCENE(""scene"");
const StringHash JSON_TYPE_NODE(""node"");
const StringHash JSON_TYPE_MATERIAL(""material"");
const StringHash JSON_TYPE_TECHNIQUE(""technique"");
const StringHash JSON_TYPE_PARTICLEEFFECT(""particleeffect"");
const StringHash JSON_TYPE_PARTICLEEMITTER(""particleemitter"");
const StringHash JSON_TYPE_TEXTURE(""texture"");
const StringHash JSON_TYPE_ELEMENT(""element"");
const StringHash JSON_TYPE_ELEMENTS(""elements"");
const StringHash JSON_TYPE_ANIMATION_SETTINGS(""animation"");
const StringHash JSON_TYPE_RENDERPATH(""renderpath"");
const StringHash JSON_TYPE_TEXTURE_ATLAS(""TextureAtlas"");
const StringHash JSON_TYPE_2D_PARTICLE_EFFECT(""particleEmitterConfig"");
const StringHash JSON_TYPE_TEXTURE_3D(""texture3d"");
const StringHash JSON_TYPE_CUBEMAP(""cubemap"");
const StringHash JSON_TYPE_SPRITER_DATA(""spriter_data"");

const StringHash BINARY_TYPE_SCENE(""USCN"");
const StringHash BINARY_TYPE_PACKAGE(""UPAK"");
const StringHash BINARY_TYPE_COMPRESSED_PACKAGE(""ULZ4"");
const StringHash BINARY_TYPE_ANGLESCRIPT(""ASBC"");
const StringHash BINARY_TYPE_MODEL(""UMDL"");
const StringHash BINARY_TYPE_SHADER(""USHD"");
const StringHash BINARY_TYPE_ANIMATION(""UANI"");

const StringHash EXTENSION_TYPE_TTF("".ttf"");
const StringHash EXTENSION_TYPE_OTF("".otf"");
const StringHash EXTENSION_TYPE_OGG("".ogg"");
const StringHash EXTENSION_TYPE_WAV("".wav"");
const StringHash EXTENSION_TYPE_DDS("".dds"");
const StringHash EXTENSION_TYPE_PNG("".png"");
const StringHash EXTENSION_TYPE_JPG("".jpg"");
const StringHash EXTENSION_TYPE_JPEG("".jpeg"");
const StringHash EXTENSION_TYPE_BMP("".bmp"");
const StringHash EXTENSION_TYPE_TGA("".tga"");
const StringHash EXTENSION_TYPE_KTX("".ktx"");
const StringHash EXTENSION_TYPE_PVR("".pvr"");
const StringHash EXTENSION_TYPE_OBJ("".obj"");
const StringHash EXTENSION_TYPE_FBX("".fbx"");
const StringHash EXTENSION_TYPE_COLLADA("".dae"");
const StringHash EXTENSION_TYPE_BLEND("".blend"");
const StringHash EXTENSION_TYPE_ANGELSCRIPT("".as"");
const StringHash EXTENSION_TYPE_LUASCRIPT("".lua"");
const StringHash EXTENSION_TYPE_HLSL("".hlsl"");
const StringHash EXTENSION_TYPE_GLSL("".glsl"");
const StringHash EXTENSION_TYPE_FRAGMENTSHADER("".frag"");
const StringHash EXTENSION_TYPE_VERTEXSHADER("".vert"");
const StringHash EXTENSION_TYPE_HTML("".html"");

const StringHash TEXT_VAR_FILE_ID(""browser_file_id"");
const StringHash TEXT_VAR_DIR_ID(""browser_dir_id"");
const StringHash TEXT_VAR_RESOURCE_TYPE(""resource_type"");
const StringHash TEXT_VAR_RESOURCE_DIR_ID(""resource_dir_id"");

const int BROWSER_FILE_SOURCE_RESOURCE_DIR = 1;

uint browserDirIndex = 1;
uint browserFileIndex = 1;
BrowserDir@ selectedBrowserDirectory;
BrowserFile@ selectedBrowserFile;
Text@ browserStatusMessage;
Text@ browserResultsMessage;
bool ignoreRefreshBrowserResults = false;
String resourceDirsCache;

void CreateResourceBrowser()
{
    if (browserWindow !is null) return;

    CreateResourceBrowserUI();
    InitResourceBrowserPreview();
    RebuildResourceDatabase();
}

void RebuildResourceDatabase()
{
    if (browserWindow is null)
        return;

    String newResourceDirsCache = Join(cache.resourceDirs, ';');
    ScanResourceDirectories();
    if (newResourceDirsCache != resourceDirsCache)
    {
        resourceDirsCache = newResourceDirsCache;
        PopulateResourceDirFilters();
    }
    PopulateBrowserDirectories();
    PopulateResourceBrowserFilesByDirectory(rootDir);
}

void ScanResourceDirectories()
{
    browserDirs.Clear();
    browserFiles.Clear();
    browserFilesToScan.Clear();

    rootDir = BrowserDir("""");
    browserDirs.Set("""", @rootDir);

    // collect all of the items and sort them afterwards
    for(uint i=0; i < cache.resourceDirs.length; ++i)
    {
        if (activeResourceDirFilters.Find(i) > -1)
            continue;

        ScanResourceDir(i);
    }
}

// used to stop ui from blocking while determining file types
void DoResourceBrowserWork()
{
    if (browserFilesToScan.length == 0)
        return;

    int counter = 0;
    bool updateBrowserUI = false;
    BrowserFile@ scanItem = browserFilesToScan[0];
    while(counter < BROWSER_WORKER_ITEMS_PER_TICK)
    {
        scanItem.DetermainResourceType();

        // next
        browserFilesToScan.Erase(0);
        if (browserFilesToScan.length > 0)
            @scanItem = browserFilesToScan[0];
        else
            break;
        counter++;
    }

    if (browserFilesToScan.length > 0)
        browserStatusMessage.text = localization.Get(""Files left to scan: "" )+ browserFilesToScan.length;
    else
        browserStatusMessage.text = localization.Get(""Scan complete"");

}

void CreateResourceBrowserUI()
{
    browserWindow = LoadEditorUI(""UI/EditorResourceBrowser.xml"");
    browserDirList = browserWindow.GetChild(""DirectoryList"", true);
    browserFileList = browserWindow.GetChild(""FileList"", true);
    browserSearch = browserWindow.GetChild(""Search"", true);
    browserStatusMessage = browserWindow.GetChild(""StatusMessage"", true);
    browserResultsMessage = browserWindow.GetChild(""ResultsMessage"", true);
    // browserWindow.visible = false;
    browserWindow.opacity = uiMaxOpacity;

    browserFilterWindow = LoadEditorUI(""UI/EditorResourceFilterWindow.xml"");
    CreateResourceFilterUI();
    HideResourceFilterWindow();

    int height = Min(ui.root.height / 4, 300);
    browserWindow.SetSize(900, height);
    browserWindow.SetPosition(35, ui.root.height - height - 25);

    CloseContextMenu();
    ui.root.AddChild(browserWindow);
    ui.root.AddChild(browserFilterWindow);

    SubscribeToEvent(browserWindow.GetChild(""CloseButton"", true), ""Released"", ""HideResourceBrowserWindow"");
    SubscribeToEvent(browserWindow.GetChild(""RescanButton"", true), ""Released"", ""HandleRescanResourceBrowserClick"");
    SubscribeToEvent(browserWindow.GetChild(""FilterButton"", true), ""Released"", ""ToggleResourceFilterWindow"");
    SubscribeToEvent(browserDirList, ""SelectionChanged"", ""HandleResourceBrowserDirListSelectionChange"");
    SubscribeToEvent(browserSearch, ""TextChanged"", ""HandleResourceBrowserSearchTextChange"");
    SubscribeToEvent(browserFileList, ""ItemClicked"", ""HandleBrowserFileClick"");
    SubscribeToEvent(browserFileList, ""SelectionChanged"", ""HandleResourceBrowserFileListSelectionChange"");
    SubscribeToEvent(cache, ""FileChanged"", ""HandleFileChanged"");
}

void CreateResourceFilterUI()
{
    UIElement@ options = browserFilterWindow.GetChild(""TypeOptions"", true);
    CheckBox@ toggleAllTypes = browserFilterWindow.GetChild(""ToggleAllTypes"", true);
    CheckBox@ toggleAllResourceDirs = browserFilterWindow.GetChild(""ToggleAllResourceDirs"", true);
    SubscribeToEvent(toggleAllTypes, ""Toggled"", ""HandleResourceTypeFilterToggleAllTypesToggled"");
    SubscribeToEvent(toggleAllResourceDirs, ""Toggled"", ""HandleResourceDirFilterToggleAllTypesToggled"");
    SubscribeToEvent(browserFilterWindow.GetChild(""CloseButton"", true), ""Released"", ""HideResourceFilterWindow"");

    int columns = 2;
    UIElement@ col1 = browserFilterWindow.GetChild(""TypeFilterColumn1"", true);
    UIElement@ col2 = browserFilterWindow.GetChild(""TypeFilterColumn2"", true);

    // use array to get sort of items
    Array<ResourceType@> sorted;
    for (int i=1; i <= NUMBER_OF_VALID_RESOURCE_TYPES; ++i)
        sorted.Push(ResourceType(i, ResourceTypeName(i)));
        
    // 2 unknown types are reserved for the top, the rest are alphabetized
    sorted.Sort();
    sorted.Insert(0, ResourceType(RESOURCE_TYPE_UNKNOWN, ResourceTypeName(RESOURCE_TYPE_UNKNOWN)) );
    sorted.Insert(0, ResourceType(RESOURCE_TYPE_UNUSABLE,  ResourceTypeName(RESOURCE_TYPE_UNUSABLE)) );
    int halfColumns = Ceil( float(sorted.length) / float(columns) );

    for (uint i = 0; i < sorted.length; ++i)
    {
        ResourceType@ type = sorted[i];
        UIElement@ resourceTypeHolder = UIElement();
        if (i < halfColumns)
            col1.AddChild(resourceTypeHolder);
        else
            col2.AddChild(resourceTypeHolder);

        resourceTypeHolder.layoutMode = LM_HORIZONTAL;
        resourceTypeHolder.layoutSpacing = 4;

        Text@ label = Text();
        label.style = ""EditorAttributeText"";
        label.text = type.name;
        CheckBox@ checkbox = CheckBox();
        checkbox.name = type.id;
        checkbox.SetStyleAuto();
        checkbox.vars[TEXT_VAR_RESOURCE_TYPE] = i;
        checkbox.checked = true;
        SubscribeToEvent(checkbox, ""Toggled"", ""HandleResourceTypeFilterToggled"");

        resourceTypeHolder.AddChild(checkbox);
        resourceTypeHolder.AddChild(label);
    }
}

void CreateDirList(BrowserDir@ dir, UIElement@ parentUI = null)
{
    Text@ dirText = Text();
    browserDirList.InsertItem(browserDirList.numItems, dirText, parentUI);
    dirText.style = ""FileSelectorListText"";
    dirText.text = dir.resourceKey.empty ? localization.Get(""Root"") : dir.name;
    dirText.name = dir.resourceKey;
    dirText.vars[TEXT_VAR_DIR_ID] = dir.resourceKey;

    // Sort directories alphetically
    browserSearchSortMode = BROWSER_SORT_MODE_ALPHA;
    dir.children.Sort();

    for(uint i=0; i<dir.children.length; ++i)
        CreateDirList(dir.children[i], dirText);
}

void CreateFileList(BrowserFile@ file)
{
    Text@ fileText = Text();
    fileText.style = ""FileSelectorListText"";
    fileText.layoutMode = LM_HORIZONTAL;
    browserFileList.InsertItem(browserFileList.numItems, fileText);
    file.browserFileListRow = fileText;
    InitializeBrowserFileListRow(fileText, file);
}

void InitializeBrowserFileListRow(Text@ fileText, BrowserFile@ file)
{
    fileText.RemoveAllChildren();
    VariantMap params = VariantMap();
    fileText.vars[TEXT_VAR_FILE_ID] = file.id;
    fileText.vars[TEXT_VAR_RESOURCE_TYPE] = file.resourceType;
    if (file.resourceType > 0)
        fileText.dragDropMode = DD_SOURCE;

    {
        Text@ text = Text();
        fileText.AddChild(text);
        text.style = ""FileSelectorListText"";
        text.text = file.fullname;
        text.name = file.resourceKey;
    }

    {
        Text@ text = Text();
        fileText.AddChild(text);
        text.style = ""FileSelectorListText"";
        text.text = file.ResourceTypeName();
    }

    if (file.resourceType == RESOURCE_TYPE_MATERIAL || 
            file.resourceType == RESOURCE_TYPE_MODEL ||
            file.resourceType == RESOURCE_TYPE_PARTICLEEFFECT ||
            file.resourceType == RESOURCE_TYPE_PREFAB
        )
    {
        SubscribeToEvent(fileText, ""DragBegin"", ""HandleBrowserFileDragBegin"");
        SubscribeToEvent(fileText, ""DragEnd"", ""HandleBrowserFileDragEnd"");
    }

}

void InitResourceBrowserPreview()
{
    resourcePreviewScene = Scene(""PreviewScene"");
    resourcePreviewScene.CreateComponent(""Octree"");
    PhysicsWorld@ physicsWorld = resourcePreviewScene.CreateComponent(""PhysicsWorld"");
    physicsWorld.enabled = false;
    physicsWorld.gravity = Vector3(0.0, 0.0, 0.0);

    Node@ zoneNode = resourcePreviewScene.CreateChild(""Zone"");
    Zone@ zone = zoneNode.CreateComponent(""Zone"");
    zone.boundingBox = BoundingBox(-1000, 1000);
    zone.ambientColor = Color(0.15, 0.15, 0.15);
    zone.fogColor = Color(0, 0, 0);
    zone.fogStart = 10.0;
    zone.fogEnd = 100.0;

    resourcePreviewCameraNode = resourcePreviewScene.CreateChild(""PreviewCamera"");
    resourcePreviewCameraNode.position = Vector3(0, 0, -1.5);
    Camera@ camera = resourcePreviewCameraNode.CreateComponent(""Camera"");
    camera.nearClip = 0.1f;
    camera.farClip = 100.0f;

    resourcePreviewLightNode = resourcePreviewScene.CreateChild(""PreviewLight"");
    resourcePreviewLightNode.direction = Vector3(0.5, -0.5, 0.5);
    resourcePreviewLight = resourcePreviewLightNode.CreateComponent(""Light"");
    resourcePreviewLight.lightType = LIGHT_DIRECTIONAL;
    resourcePreviewLight.specularIntensity = 0.5;

    resourceBrowserPreview = browserWindow.GetChild(""ResourceBrowserPreview"", true);
    resourceBrowserPreview.SetFixedHeight(200);
    resourceBrowserPreview.SetFixedWidth(266);
    resourceBrowserPreview.SetView(resourcePreviewScene, camera);
    resourceBrowserPreview.autoUpdate = false;

    resourcePreviewNode = resourcePreviewScene.CreateChild(""PreviewNodeContainer"");

    SubscribeToEvent(resourceBrowserPreview, ""DragMove"", ""RotateResourceBrowserPreview"");

    RefreshBrowserPreview();
}

// Opens a contextual menu based on what resource item was actioned
void HandleBrowserFileClick(StringHash eventType, VariantMap& eventData)
{
    if (eventData[""Button""].GetInt() != MOUSEB_RIGHT)
        return;

    UIElement@ uiElement = eventData[""Item""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(uiElement);

    if (file is null)
        return;

    Array<UIElement@> actions;
    if (file.resourceType == RESOURCE_TYPE_MATERIAL)
    {
        actions.Push(CreateBrowserFileActionMenu(""Edit"", ""HandleBrowserEditResource"", file));
    }
    else if (file.resourceType == RESOURCE_TYPE_MODEL)
    {
        actions.Push(CreateBrowserFileActionMenu(""Instance Animated Model"", ""HandleBrowserInstantiateAnimatedModel"", file));
        actions.Push(CreateBrowserFileActionMenu(""Instance Static Model"", ""HandleBrowserInstantiateStaticModel"", file));
    }
    else if (file.resourceType == RESOURCE_TYPE_PREFAB)
    {
        actions.Push(CreateBrowserFileActionMenu(""Instance Prefab"", ""HandleBrowserInstantiatePrefab"", file));
        actions.Push(CreateBrowserFileActionMenu(""Instance in Spawner"", ""HandleBrowserInstantiateInSpawnEditor"", file));
    }
    else if (file.fileType == EXTENSION_TYPE_OBJ ||
        file.fileType == EXTENSION_TYPE_COLLADA ||
        file.fileType == EXTENSION_TYPE_FBX ||
        file.fileType == EXTENSION_TYPE_BLEND)
    {
        actions.Push(CreateBrowserFileActionMenu(""Import Model"", ""HandleBrowserImportModel"", file));
        actions.Push(CreateBrowserFileActionMenu(""Import Scene"", ""HandleBrowserImportScene"", file));
    }
    else if (file.resourceType == RESOURCE_TYPE_UIELEMENT)
    {
        actions.Push(CreateBrowserFileActionMenu(""Open UI Layout"", ""HandleBrowserOpenUILayout"", file));
    }
    else if (file.resourceType == RESOURCE_TYPE_SCENE)
    {
        actions.Push(CreateBrowserFileActionMenu(""Load Scene"", ""HandleBrowserLoadScene"", file));
    }
    else if (file.resourceType == RESOURCE_TYPE_SCRIPTFILE)
    {
        actions.Push(CreateBrowserFileActionMenu(""Execute Script"", ""HandleBrowserRunScript"", file));
    }
    else if (file.resourceType == RESOURCE_TYPE_PARTICLEEFFECT)
    {
        actions.Push(CreateBrowserFileActionMenu(""Edit"", ""HandleBrowserEditResource"", file));
    }

    actions.Push(CreateBrowserFileActionMenu(""Open"", ""HandleBrowserOpenResource"", file));

    ActivateContextMenu(actions);
}

BrowserDir@ GetBrowserDir(String path)
{
    BrowserDir@ browserDir;
    browserDirs.Get(path, @browserDir);
    return browserDir;
}

// Makes sure the entire directory tree exists and new dir is linked to parent
BrowserDir@ InitBrowserDir(String path)
{
    BrowserDir@ browserDir;
    if (browserDirs.Get(path, @browserDir))
        return browserDir;

    Array<String> parts = path.Split('/');
    Array<String> finishedParts;
    if (parts.length > 0)
    {
        BrowserDir@ parent = rootDir;
        for( uint i = 0; i < parts.length; ++i )
        {
            finishedParts.Push(parts[i]);
            String currentPath = Join(finishedParts, ""/"");
            if (!browserDirs.Get(currentPath, @browserDir))
            {
                browserDir = BrowserDir(currentPath);
                browserDirs.Set(currentPath, @browserDir);
                parent.children.Push(browserDir);
            }
            @parent = browserDir;
        } 
        return browserDir;
    }
    return null;
}

void ScanResourceDir(uint resourceDirIndex)
{
    String resourceDir = cache.resourceDirs[resourceDirIndex];
    ScanResourceDirFiles("""", resourceDirIndex);
    Array<String> dirs = fileSystem.ScanDir(resourceDir, ""*"", SCAN_DIRS, true);
    for (uint i=0; i < dirs.length; ++i)
    {
        String path = dirs[i];
        if (path.EndsWith("".""))
            continue;

        InitBrowserDir(path);
        ScanResourceDirFiles(path, resourceDirIndex);
    }
}

void ScanResourceDirFiles(String path, uint resourceDirIndex)
{
    String fullPath = cache.resourceDirs[resourceDirIndex] + path;
    if (!fileSystem.DirExists(fullPath))
        return;

    BrowserDir@ dir = GetBrowserDir(path);

    if (dir is null)
        return;

    // get files in directory
    Array<String> dirFiles = fileSystem.ScanDir(fullPath, ""*.*"", SCAN_FILES, false);

    // add new files
    for (uint x=0; x < dirFiles.length; x++)
    {
        String filename = dirFiles[x];
        BrowserFile@ browserFile = dir.AddFile(filename, resourceDirIndex, BROWSER_FILE_SOURCE_RESOURCE_DIR);
        browserFiles.Push(browserFile);
        browserFilesToScan.Push(browserFile);
    }
}

bool ToggleResourceBrowserWindow()
{
    if (browserWindow.visible == false)
        ShowResourceBrowserWindow();
    else
        HideResourceBrowserWindow();
    return true;
}

void ShowResourceBrowserWindow()
{
    browserWindow.visible = true;
    browserWindow.BringToFront();
    ui.focusElement = browserSearch;
}

void HideResourceBrowserWindow()
{
    browserWindow.visible = false;
}

void ToggleResourceFilterWindow()
{
    if (browserFilterWindow.visible)
        HideResourceFilterWindow();
    else
        ShowResourceFilterWindow();
}
void HideResourceFilterWindow()
{
    browserFilterWindow.visible = false;
}

void ShowResourceFilterWindow()
{
    int x = browserWindow.position.x + browserWindow.width - browserFilterWindow.width;
    int y = browserWindow.position.y - browserFilterWindow.height - 1;
    browserFilterWindow.position = IntVector2(x,y);
    browserFilterWindow.visible = true;
    browserFilterWindow.BringToFront();
}

void PopulateResourceDirFilters()
{
    UIElement@ resourceDirs = browserFilterWindow.GetChild(""DirFilters"", true);
    resourceDirs.RemoveAllChildren();
    activeResourceDirFilters.Clear();
    for (uint i=0; i < cache.resourceDirs.length; ++i)
    {
        UIElement@ resourceDirHolder = UIElement();
        resourceDirs.AddChild(resourceDirHolder);
        resourceDirHolder.layoutMode = LM_HORIZONTAL;
        resourceDirHolder.layoutSpacing = 4;
        resourceDirHolder.SetFixedHeight(16);

        Text@ label = Text();
        label.style = ""EditorAttributeText"";
        label.text = cache.resourceDirs[i].Replaced(fileSystem.programDir, """");
        CheckBox@ checkbox = CheckBox();
        checkbox.name = i;
        checkbox.SetStyleAuto();
        checkbox.vars[TEXT_VAR_RESOURCE_DIR_ID] = i;
        checkbox.checked = true;
        SubscribeToEvent(checkbox, ""Toggled"", ""HandleResourceDirFilterToggled"");


        resourceDirHolder.AddChild(checkbox);
        resourceDirHolder.AddChild(label);
    }

}

void PopulateBrowserDirectories()
{
    browserDirList.RemoveAllItems();
    CreateDirList(rootDir);
    browserDirList.selection = 0;
}

void PopulateResourceBrowserFilesByDirectory(BrowserDir@ dir)
{
    @selectedBrowserDirectory = dir;
    browserFileList.RemoveAllItems();
    if (dir is null) return;

    Array<BrowserFile@> files;
    for(uint x=0; x < dir.files.length; x++)
    {
        BrowserFile@ file = dir.files[x];

        if (activeResourceTypeFilters.Find(file.resourceType) == -1)
            files.Push(file);
    }

    // Sort alphetically
    browserSearchSortMode = BROWSER_SORT_MODE_ALPHA;
    files.Sort();
    PopulateResourceBrowserResults(files);
    browserResultsMessage.text = localization.Get(""Showing files: "") + files.length;
}


void PopulateResourceBrowserBySearch()
{
    String query = browserSearch.text;

    Array<int> scores;
    Array<BrowserFile@> scored;
    Array<BrowserFile@> filtered;
    {
        BrowserFile@ file;
        for(uint x=0; x < browserFiles.length; x++)
        {
            @file = browserFiles[x];
            file.sortScore = -1;
            if (activeResourceTypeFilters.Find(file.resourceType) > -1)
                continue;

            if (activeResourceDirFilters.Find(file.resourceSourceIndex) > -1)
                continue;

            int find = file.fullname.Find(query, 0, false);
            if (find > -1)
            {
                int fudge = query.length - file.fullname.length;
                int score = find * int(Abs(fudge*2)) + int(Abs(fudge));
                file.sortScore = score;
                scored.Push(file);
                scores.Push(score);
            }
        }
    }

    // cut this down for a faster sort
    if (scored.length > BROWSER_SEARCH_LIMIT)
    {
        scores.Sort();
        int scoreThreshold = scores[BROWSER_SEARCH_LIMIT];
        BrowserFile@ file;
        for(uint x=0;x<scored.length;x++)
        {
            file = scored[x];
            if (file.sortScore <= scoreThreshold)
                filtered.Push(file);
        }
    }
    else
        filtered = scored;

    browserSearchSortMode = BROWSER_SORT_MODE_ALPHA;
    filtered.Sort();
    PopulateResourceBrowserResults(filtered);
    browserResultsMessage.text = ""Showing top "" + filtered.length + "" of "" + scored.length + "" results"";
}

void PopulateResourceBrowserResults(Array<BrowserFile@>@ files)
{
    browserFileList.RemoveAllItems();
    for(uint i=0; i < files.length; ++i)
        CreateFileList(files[i]);
}

void RefreshBrowserResults()
{
    if (browserSearch.text.empty)
    {
        browserDirList.visible = true;
        PopulateResourceBrowserFilesByDirectory(selectedBrowserDirectory);
    }
    else
    {
        browserDirList.visible = false;
        PopulateResourceBrowserBySearch();
    }
}

void HandleResourceTypeFilterToggleAllTypesToggled(StringHash eventType, VariantMap& eventData)
{
    CheckBox@ checkbox = eventData[""Element""].GetPtr();
    UIElement@ filterHolder = browserFilterWindow.GetChild(""TypeFilters"", true);
    Array<UIElement@> children = filterHolder.GetChildren(true);

    ignoreRefreshBrowserResults = true;
    for(uint i=0; i < children.length; ++i)
    {
        CheckBox@ filter = children[i];
        if (filter !is null)
            filter.checked = checkbox.checked;
    }
    ignoreRefreshBrowserResults = false;
    RefreshBrowserResults();
}

void HandleResourceTypeFilterToggled(StringHash eventType, VariantMap& eventData)
{
    CheckBox@ checkbox = eventData[""Element""].GetPtr();
    if (!checkbox.vars.Contains(TEXT_VAR_RESOURCE_TYPE))
        return;

    int resourceType = checkbox.GetVar(TEXT_VAR_RESOURCE_TYPE).GetInt();
    int find = activeResourceTypeFilters.Find(resourceType);

    if (checkbox.checked && find != -1)
        activeResourceTypeFilters.Erase(find);
    else if (!checkbox.checked && find == -1)
        activeResourceTypeFilters.Push(resourceType);

    if (ignoreRefreshBrowserResults == false)
        RefreshBrowserResults();
}

void HandleResourceDirFilterToggleAllTypesToggled(StringHash eventType, VariantMap& eventData)
{
    CheckBox@ checkbox = eventData[""Element""].GetPtr();
    UIElement@ filterHolder = browserFilterWindow.GetChild(""DirFilters"", true);
    Array<UIElement@> children = filterHolder.GetChildren(true);

    ignoreRefreshBrowserResults = true;
    for(uint i=0; i < children.length; ++i)
    {
        CheckBox@ filter = children[i];
        if (filter !is null)
            filter.checked = checkbox.checked;
    }
    ignoreRefreshBrowserResults = false;
    RebuildResourceDatabase();
}

void HandleResourceDirFilterToggled(StringHash eventType, VariantMap& eventData)
{
    CheckBox@ checkbox = eventData[""Element""].GetPtr();
    if (!checkbox.vars.Contains(TEXT_VAR_RESOURCE_DIR_ID))
        return;

    int resourceDir = checkbox.GetVar(TEXT_VAR_RESOURCE_DIR_ID).GetInt();
    int find = activeResourceDirFilters.Find(resourceDir);

    if (checkbox.checked && find != -1)
        activeResourceDirFilters.Erase(find);
    else if (!checkbox.checked && find == -1)
        activeResourceDirFilters.Push(resourceDir);

    if (ignoreRefreshBrowserResults == false)
        RebuildResourceDatabase();
}

void HandleRescanResourceBrowserClick(StringHash eventType, VariantMap& eventData)
{
    RebuildResourceDatabase();
}

void HandleResourceBrowserDirListSelectionChange(StringHash eventType, VariantMap& eventData)
{
    if (browserDirList.selection == M_MAX_UNSIGNED)
        return;

    UIElement@ uiElement = browserDirList.GetItems()[browserDirList.selection];
    BrowserDir@ dir = GetBrowserDir(uiElement.vars[TEXT_VAR_DIR_ID].GetString());
    if (dir is null)
        return;

    PopulateResourceBrowserFilesByDirectory(dir);
}

void HandleResourceBrowserFileListSelectionChange(StringHash eventType, VariantMap& eventData)
{
    if (browserFileList.selection == M_MAX_UNSIGNED)
        return;

    UIElement@ uiElement = browserFileList.GetItems()[browserFileList.selection];
    BrowserFile@ file = GetBrowserFileFromUIElement(uiElement);
    if (file is null)
        return;

    if (resourcePreviewNode !is null)
        resourcePreviewNode.Remove();

    resourcePreviewNode = resourcePreviewScene.CreateChild(""PreviewNodeContainer"");
    CreateResourcePreview(file.GetFullPath(), resourcePreviewNode);

    if (resourcePreviewNode !is null)
    {
        Array<BoundingBox> boxes;
        Array<Component@> staticModels = resourcePreviewNode.GetComponents(""StaticModel"", true);
        Array<Component@> animatedModels = resourcePreviewNode.GetComponents(""AnimatedModel"", true);

        for (uint i = 0; i < staticModels.length; ++i)
            boxes.Push(cast<StaticModel>(staticModels[i]).worldBoundingBox);

        for (uint i = 0; i < animatedModels.length; ++i)
            boxes.Push(cast<AnimatedModel>(animatedModels[i]).worldBoundingBox);

        if (boxes.length > 0)
        {
            Vector3 camPosition = Vector3(0.0, 0.0, -1.2);
            BoundingBox biggestBox = boxes[0];
            for (uint i = 1; i < boxes.length; ++i)
            {
                if (boxes[i].size.length > biggestBox.size.length)
                    biggestBox = boxes[i];
            }
            resourcePreviewCameraNode.position = biggestBox.center + camPosition * biggestBox.size.length;
        }

        resourcePreviewScene.AddChild(resourcePreviewNode);
        RefreshBrowserPreview();
    }
}

void HandleResourceBrowserSearchTextChange(StringHash eventType, VariantMap& eventData)
{
    RefreshBrowserResults();
}

BrowserFile@ GetBrowserFileFromId(uint id)
{
    if (id == 0)
        return null;

    BrowserFile@ file;
    for(uint i=0; i<browserFiles.length; ++i)
    {
        @file = @browserFiles[i];
        if (file.id == id) return file;
    }
    return null;
}

BrowserFile@ GetBrowserFileFromUIElement(UIElement@ element)
{
    if (element is null || !element.vars.Contains(TEXT_VAR_FILE_ID))
        return null;
    return GetBrowserFileFromId(element.vars[TEXT_VAR_FILE_ID].GetUInt());
}

BrowserFile@ GetBrowserFileFromPath(String path)
{
    for (uint i=0; i < browserFiles.length; ++i)
    {
        BrowserFile@ file = browserFiles[i];
        if (path == file.GetFullPath())
            return file;
    }
    return null;
}

void HandleBrowserEditResource(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file is null)
        return;

    if (file.resourceType == RESOURCE_TYPE_MATERIAL)
    {
        Material@ material = cache.GetResource(""Material"", file.resourceKey);
        if (material !is null)
            EditMaterial(material);
    }

    if (file.resourceType == RESOURCE_TYPE_PARTICLEEFFECT)
    {
        ParticleEffect@ particleEffect = cache.GetResource(""ParticleEffect"", file.resourceKey);
        if (particleEffect !is null)
            EditParticleEffect(particleEffect);
    }
}

void HandleBrowserOpenResource(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        OpenResource(file.resourceKey);
}

void HandleBrowserImportScene(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        ImportScene(file.GetFullPath());
}

void HandleBrowserImportModel(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        ImportModel(file.GetFullPath());
}

void HandleBrowserOpenUILayout(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        OpenUILayout(file.GetFullPath());
}

void HandleBrowserInstantiateStaticModel(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        CreateModelWithStaticModel(file.resourceKey, editNode);
}

void HandleBrowserInstantiateAnimatedModel(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        CreateModelWithAnimatedModel(file.resourceKey, editNode);
}

void HandleBrowserInstantiatePrefab(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        LoadNode(file.GetFullPath());
}

void HandleBrowserInstantiateInSpawnEditor(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
    {
        spawnedObjectsNames.Resize(1);
        spawnedObjectsNames[0] = VerifySpawnedObjectFile(file.GetPath());
        RefreshPickedObjects();
        ShowSpawnEditor();
    }
}

void HandleBrowserLoadScene(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        LoadScene(file.GetFullPath());
}

void HandleBrowserRunScript(StringHash eventType, VariantMap& eventData)
{
    UIElement@ element = eventData[""Element""].GetPtr();
    BrowserFile@ file = GetBrowserFileFromUIElement(element);
    if (file !is null)
        ExecuteScript(ExtractFileName(eventData));
}

void HandleBrowserFileDragBegin(StringHash eventType, VariantMap& eventData)
{
    UIElement@ uiElement = eventData[""Element""].GetPtr();
    @browserDragFile = GetBrowserFileFromUIElement(uiElement);
}

void HandleBrowserFileDragEnd(StringHash eventType, VariantMap& eventData)
{
    if (@browserDragFile is null)
        return;

    UIElement@ element = ui.GetElementAt(ui.cursor.screenPosition);
    if (element !is null)
        return;

    if (browserDragFile.resourceType == RESOURCE_TYPE_MATERIAL)
    {
        StaticModel@ model = cast<StaticModel>(GetDrawableAtMousePostion());
        if (model !is null)
        {
            AssignMaterial(model, browserDragFile.resourceKey);
        }
    }

    browserDragFile = null;
    browserDragComponent = null;
    browserDragNode = null;
}

void HandleFileChanged(StringHash eventType, VariantMap& eventData)
{
    String filename = eventData[""FileName""].GetString();
    BrowserFile@ file = GetBrowserFileFromPath(filename);
    
    if (file is null)
    {
        // TODO: new file logic when watchers are supported 
        return;
    }
    else
    {
        file.FileChanged();
    }
}

Menu@ CreateBrowserFileActionMenu(String text, String handler, BrowserFile@ browserFile = null)
{
    Menu@ menu = CreateContextMenuItem(text, handler);
    if (browserFile !is null)
        menu.vars[TEXT_VAR_FILE_ID] = browserFile.id;

    return menu;
}

int GetResourceType(String path)
{
    StringHash fileType;
    return GetResourceType(path, fileType);
}

int GetResourceType(String path, StringHash &out fileType, bool useCache = false)
{
    if (GetExtensionType(path, fileType) || GetBinaryType(path, fileType, useCache) || GetXmlType(path, fileType, useCache))
        return GetResourceType(fileType);

    return RESOURCE_TYPE_UNKNOWN;
}


int GetResourceType(StringHash fileType)
{
    // binary fileTypes
    if (fileType == BINARY_TYPE_SCENE)
        return RESOURCE_TYPE_SCENE;
    else if (fileType == BINARY_TYPE_PACKAGE)
        return RESOURCE_TYPE_UNUSABLE;
    else if (fileType == BINARY_TYPE_COMPRESSED_PACKAGE)
        return RESOURCE_TYPE_UNUSABLE;
    else if (fileType == BINARY_TYPE_ANGLESCRIPT)
        return RESOURCE_TYPE_SCRIPTFILE;
    else if (fileType == BINARY_TYPE_MODEL)
        return RESOURCE_TYPE_MODEL;
    else if (fileType == BINARY_TYPE_SHADER)
        return RESOURCE_TYPE_UNUSABLE;
    else if (fileType == BINARY_TYPE_ANIMATION)
        return RESOURCE_TYPE_ANIMATION;

    // xml fileTypes
    else if (fileType == XML_TYPE_SCENE)
        return RESOURCE_TYPE_SCENE;
    else if (fileType == XML_TYPE_NODE)
        return RESOURCE_TYPE_PREFAB;
    else if(fileType == XML_TYPE_MATERIAL)
        return RESOURCE_TYPE_MATERIAL;
    else if(fileType == XML_TYPE_TECHNIQUE)
        return RESOURCE_TYPE_TECHNIQUE;
    else if(fileType == XML_TYPE_PARTICLEEFFECT)
        return RESOURCE_TYPE_PARTICLEEFFECT;
    else if(fileType == XML_TYPE_PARTICLEEMITTER)
        return RESOURCE_TYPE_PARTICLEEMITTER;
    else if(fileType == XML_TYPE_TEXTURE)
        return RESOURCE_TYPE_TEXTURE;
    else if(fileType == XML_TYPE_ELEMENT)
        return RESOURCE_TYPE_UIELEMENT;
    else if(fileType == XML_TYPE_ELEMENTS)
        return RESOURCE_TYPE_UIELEMENTS;
    else if (fileType == XML_TYPE_ANIMATION_SETTINGS)
        return RESOURCE_TYPE_ANIMATION_SETTINGS;
    else if (fileType == XML_TYPE_RENDERPATH)
        return RESOURCE_TYPE_RENDERPATH;
    else if (fileType == XML_TYPE_TEXTURE_ATLAS)
        return RESOURCE_TYPE_TEXTURE_ATLAS;
    else if (fileType == XML_TYPE_2D_PARTICLE_EFFECT)
        return RESOURCE_TYPE_2D_PARTICLE_EFFECT;
    else if (fileType == XML_TYPE_TEXTURE_3D)
        return RESOURCE_TYPE_TEXTURE_3D;
    else if (fileType == XML_TYPE_CUBEMAP)
        return RESOURCE_TYPE_CUBEMAP;
    else if (fileType == XML_TYPE_SPRITER_DATA)
        return RESOURCE_TYPE_2D_ANIMATION_SET;
   
    // JSON fileTypes
    else if (fileType == JSON_TYPE_SCENE)
        return RESOURCE_TYPE_SCENE;
    else if (fileType == JSON_TYPE_NODE)
        return RESOURCE_TYPE_PREFAB;
    else if(fileType == JSON_TYPE_MATERIAL)
        return RESOURCE_TYPE_MATERIAL;
    else if(fileType == JSON_TYPE_TECHNIQUE)
        return RESOURCE_TYPE_TECHNIQUE;
    else if(fileType == JSON_TYPE_PARTICLEEFFECT)
        return RESOURCE_TYPE_PARTICLEEFFECT;
    else if(fileType == JSON_TYPE_PARTICLEEMITTER)
        return RESOURCE_TYPE_PARTICLEEMITTER;
    else if(fileType == JSON_TYPE_TEXTURE)
        return RESOURCE_TYPE_TEXTURE;
    else if(fileType == JSON_TYPE_ELEMENT)
        return RESOURCE_TYPE_UIELEMENT;
    else if(fileType == JSON_TYPE_ELEMENTS)
        return RESOURCE_TYPE_UIELEMENTS;
    else if (fileType == JSON_TYPE_ANIMATION_SETTINGS)
        return RESOURCE_TYPE_ANIMATION_SETTINGS;
    else if (fileType == JSON_TYPE_RENDERPATH)
        return RESOURCE_TYPE_RENDERPATH;
    else if (fileType == JSON_TYPE_TEXTURE_ATLAS)
        return RESOURCE_TYPE_TEXTURE_ATLAS;
    else if (fileType == JSON_TYPE_2D_PARTICLE_EFFECT)
        return RESOURCE_TYPE_2D_PARTICLE_EFFECT;
    else if (fileType == JSON_TYPE_TEXTURE_3D)
        return RESOURCE_TYPE_TEXTURE_3D;
    else if (fileType == JSON_TYPE_CUBEMAP)
        return RESOURCE_TYPE_CUBEMAP;
    else if (fileType == JSON_TYPE_SPRITER_DATA)
        return RESOURCE_TYPE_2D_ANIMATION_SET;

    // extension fileTypes
    else if (fileType == EXTENSION_TYPE_TTF)
        return RESOURCE_TYPE_FONT;
    else if (fileType == EXTENSION_TYPE_OTF)
        return RESOURCE_TYPE_FONT;
    else if (fileType == EXTENSION_TYPE_OGG)
        return RESOURCE_TYPE_SOUND;
    else if(fileType == EXTENSION_TYPE_WAV)
        return RESOURCE_TYPE_SOUND;
    else if(fileType == EXTENSION_TYPE_DDS)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_PNG)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_JPG)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_JPEG)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_BMP)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_TGA)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_KTX)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_PVR)
        return RESOURCE_TYPE_IMAGE;
    else if(fileType == EXTENSION_TYPE_OBJ)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_FBX)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_COLLADA)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_BLEND)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_ANGELSCRIPT)
        return RESOURCE_TYPE_SCRIPTFILE;
    else if(fileType == EXTENSION_TYPE_LUASCRIPT)
        return RESOURCE_TYPE_SCRIPTFILE;
    else if(fileType == EXTENSION_TYPE_HLSL)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_GLSL)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_FRAGMENTSHADER)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_VERTEXSHADER)
        return RESOURCE_TYPE_UNUSABLE;
    else if(fileType == EXTENSION_TYPE_HTML)
        return RESOURCE_TYPE_UNUSABLE;

    return RESOURCE_TYPE_UNKNOWN;
}

bool GetExtensionType(String path, StringHash &out fileType)
{
    StringHash type = StringHash(GetExtension(path));
    if (type == EXTENSION_TYPE_TTF)
        fileType = EXTENSION_TYPE_TTF;
    else if (type == EXTENSION_TYPE_OTF)
        fileType = EXTENSION_TYPE_OTF;
    else if (type == EXTENSION_TYPE_OGG)
        fileType = EXTENSION_TYPE_OGG;
    else if(type == EXTENSION_TYPE_WAV)
        fileType = EXTENSION_TYPE_WAV;
    else if(type == EXTENSION_TYPE_DDS)
        fileType = EXTENSION_TYPE_DDS;
    else if(type == EXTENSION_TYPE_PNG)
        fileType = EXTENSION_TYPE_PNG;
    else if(type == EXTENSION_TYPE_JPG)
        fileType = EXTENSION_TYPE_JPG;
    else if(type == EXTENSION_TYPE_JPEG)
        fileType = EXTENSION_TYPE_JPEG;
    else if(type == EXTENSION_TYPE_BMP)
        fileType = EXTENSION_TYPE_BMP;
    else if(type == EXTENSION_TYPE_TGA)
        fileType = EXTENSION_TYPE_TGA;
    else if(type == EXTENSION_TYPE_KTX)
        fileType = EXTENSION_TYPE_KTX;
    else if(type == EXTENSION_TYPE_PVR)
        fileType = EXTENSION_TYPE_PVR;
    else if(type == EXTENSION_TYPE_OBJ)
        fileType = EXTENSION_TYPE_OBJ;
    else if(type == EXTENSION_TYPE_FBX)
        fileType = EXTENSION_TYPE_FBX;
    else if(type == EXTENSION_TYPE_COLLADA)
        fileType = EXTENSION_TYPE_COLLADA;
    else if(type == EXTENSION_TYPE_BLEND)
        fileType = EXTENSION_TYPE_BLEND;
    else if(type == EXTENSION_TYPE_ANGELSCRIPT)
        fileType = EXTENSION_TYPE_ANGELSCRIPT;
    else if(type == EXTENSION_TYPE_LUASCRIPT)
        fileType = EXTENSION_TYPE_LUASCRIPT;
    else if(type == EXTENSION_TYPE_HLSL)
        fileType = EXTENSION_TYPE_HLSL;
    else if(type == EXTENSION_TYPE_GLSL)
        fileType = EXTENSION_TYPE_GLSL;
    else if(type == EXTENSION_TYPE_FRAGMENTSHADER)
        fileType = EXTENSION_TYPE_FRAGMENTSHADER;
    else if(type == EXTENSION_TYPE_VERTEXSHADER)
        fileType = EXTENSION_TYPE_VERTEXSHADER;
    else if(type == EXTENSION_TYPE_HTML)
        fileType = EXTENSION_TYPE_HTML;
    else
        return false;

    return true;
}

bool GetBinaryType(String path, StringHash &out fileType, bool useCache = false)
{   
    StringHash type;
    if (useCache)
    {
        File@ file = cache.GetFile(path);
        if (file is null)
            return false;

        if (file.size == 0)
            return false;

        type = StringHash(file.ReadFileID());
    }
    else
    {
        File@ file = File();
        if (!file.Open(path))
            return false;

        if (file.size == 0)
            return false;

        type = StringHash(file.ReadFileID());
    }

    if (type == BINARY_TYPE_SCENE)
        fileType = BINARY_TYPE_SCENE;
    else if (type == BINARY_TYPE_PACKAGE)
        fileType = BINARY_TYPE_PACKAGE;
    else if (type == BINARY_TYPE_COMPRESSED_PACKAGE)
        fileType = BINARY_TYPE_COMPRESSED_PACKAGE;
    else if (type == BINARY_TYPE_ANGLESCRIPT)
        fileType = BINARY_TYPE_ANGLESCRIPT;
    else if (type == BINARY_TYPE_MODEL)
        fileType = BINARY_TYPE_MODEL;
    else if (type == BINARY_TYPE_SHADER)
        fileType = BINARY_TYPE_SHADER;
    else if (type == BINARY_TYPE_ANIMATION)
        fileType = BINARY_TYPE_ANIMATION;
    else
        return false;

    return true;
}

bool GetXmlType(String path, StringHash &out fileType, bool useCache = false)
{
    String extension = GetExtension(path);
    if (extension == "".txt"" || extension == "".json"" || extension == "".icns"" || extension == "".atlas"")
        return false;

    String name;
    if (useCache)
    {
        XMLFile@ xml = cache.GetResource(""XMLFile"", path);
        if (xml is null)
            return false;

        name = xml.root.name;
    }
    else
    {
        File@ file = File();
        if (!file.Open(path))
            return false;

        if (file.size == 0)
            return false;

        XMLFile@ xml = XMLFile();
        if (xml.Load(file))
            name = xml.root.name;
        else
            return false;
    }

    bool found = false;
    if (!name.empty)
    {
        found = true;
        StringHash type = StringHash(name);
        if (type == XML_TYPE_SCENE)
            fileType = XML_TYPE_SCENE;
        else if (type == XML_TYPE_NODE)
            fileType = XML_TYPE_NODE;
        else if(type == XML_TYPE_MATERIAL)
            fileType = XML_TYPE_MATERIAL;
        else if(type == XML_TYPE_TECHNIQUE)
            fileType = XML_TYPE_TECHNIQUE;
        else if(type == XML_TYPE_PARTICLEEFFECT)
            fileType = XML_TYPE_PARTICLEEFFECT;
        else if(type == XML_TYPE_PARTICLEEMITTER)
            fileType = XML_TYPE_PARTICLEEMITTER;
        else if(type == XML_TYPE_TEXTURE)
            fileType = XML_TYPE_TEXTURE;
        else if(type == XML_TYPE_ELEMENT)
            fileType = XML_TYPE_ELEMENT;
        else if(type == XML_TYPE_ELEMENTS)
            fileType = XML_TYPE_ELEMENTS;
        else if (type == XML_TYPE_ANIMATION_SETTINGS)
            fileType = XML_TYPE_ANIMATION_SETTINGS;
        else if (type == XML_TYPE_RENDERPATH)
            fileType = XML_TYPE_RENDERPATH;
        else if (type == XML_TYPE_TEXTURE_ATLAS)
            fileType = XML_TYPE_TEXTURE_ATLAS;
        else if (type == XML_TYPE_2D_PARTICLE_EFFECT)
            fileType = XML_TYPE_2D_PARTICLE_EFFECT;
        else if (type == XML_TYPE_TEXTURE_3D)
            fileType = XML_TYPE_TEXTURE_3D;
        else if (type == XML_TYPE_CUBEMAP)
            fileType = XML_TYPE_CUBEMAP;
        else if (type == XML_TYPE_SPRITER_DATA)
            fileType = XML_TYPE_SPRITER_DATA;
        else
            found = false;
    }
    return found;
}

String ResourceTypeName(int resourceType)
{
    if (resourceType == RESOURCE_TYPE_UNUSABLE)
        return ""Unusable"";
    else if (resourceType == RESOURCE_TYPE_UNKNOWN)
        return ""Unknown"";
    else if (resourceType == RESOURCE_TYPE_NOTSET)
        return ""Uninitialized"";
    else if (resourceType == RESOURCE_TYPE_SCENE)
        return ""Scene"";
    else if (resourceType == RESOURCE_TYPE_SCRIPTFILE)
        return ""Script File"";
    else if (resourceType == RESOURCE_TYPE_MODEL)
        return ""Model"";
    else if (resourceType == RESOURCE_TYPE_MATERIAL)
        return ""Material"";
    else if (resourceType == RESOURCE_TYPE_ANIMATION)
        return ""Animation"";
    else if (resourceType == RESOURCE_TYPE_IMAGE)
        return ""Image"";
    else if (resourceType == RESOURCE_TYPE_SOUND)
        return ""Sound"";
    else if (resourceType == RESOURCE_TYPE_TEXTURE)
        return ""Texture"";
    else if (resourceType == RESOURCE_TYPE_FONT)
        return ""Font"";
    else if (resourceType == RESOURCE_TYPE_PREFAB)
        return ""Prefab"";
    else if (resourceType == RESOURCE_TYPE_TECHNIQUE)
        return ""Render Technique"";
    else if (resourceType == RESOURCE_TYPE_PARTICLEEFFECT)
        return ""Particle Effect"";
    else if (resourceType == RESOURCE_TYPE_PARTICLEEMITTER)
        return ""Particle Emitter"";
    else if (resourceType == RESOURCE_TYPE_UIELEMENT)
        return ""UI Element"";
    else if (resourceType == RESOURCE_TYPE_UIELEMENTS)
        return ""UI Elements"";
    else if (resourceType == RESOURCE_TYPE_ANIMATION_SETTINGS)
        return ""Animation Settings"";
    else if (resourceType == RESOURCE_TYPE_RENDERPATH)
        return ""Render Path"";
    else if (resourceType == RESOURCE_TYPE_TEXTURE_ATLAS)
        return ""Texture Atlas"";
    else if (resourceType == RESOURCE_TYPE_2D_PARTICLE_EFFECT)
        return ""2D Particle Effect"";
    else if (resourceType == RESOURCE_TYPE_TEXTURE_3D)
        return ""Texture 3D"";
    else if (resourceType == RESOURCE_TYPE_CUBEMAP)
        return ""Cubemap"";
    else if (resourceType == RESOURCE_TYPE_2D_ANIMATION_SET)
        return ""2D Animation Set"";
    else
        return """";
}

class BrowserDir
{
    uint id;
    String resourceKey;
    String name;
    Array<BrowserDir@> children;
    Array<BrowserFile@> files;

    BrowserDir(String path_)
    {
        resourceKey = path_;
        String parent = GetParentPath(path_);
        name = path_;
        name.Replace(parent, """");
        id = browserDirIndex++;
    }

    int opCmp(BrowserDir@ b)
    {
        return name.opCmp(b.name);
    }

    BrowserFile@ AddFile(String name, uint resourceSourceIndex, uint sourceType)
    {
        String path = resourceKey + ""/"" + name;
        BrowserFile@ file = BrowserFile(path, resourceSourceIndex, sourceType);
        files.Push(file);
        return file;
    }

}

class BrowserFile
{
    uint id;
    uint resourceSourceIndex;
    String resourceKey;
    String name;
    String fullname;
    String extension;
    StringHash fileType;
    int resourceType = 0;
    int sourceType = 0;
    int sortScore = 0;
    WeakHandle browserFileListRow;

    BrowserFile(String path_, uint resourceSourceIndex_, int sourceType_)
    {
        sourceType = sourceType_;
        resourceSourceIndex = resourceSourceIndex_;
        resourceKey = path_;
        name = GetFileName(path_);
        extension = GetExtension(path_);
        fullname = GetFileNameAndExtension(path_);
        id = browserFileIndex++;
    }

    int opCmp(BrowserFile@ b)
    {
        if (browserSearchSortMode == 1)
            return fullname.opCmp(b.fullname);
        else
            return sortScore - b.sortScore;
    }

    String GetResourceSource()
    {
        if (sourceType == BROWSER_FILE_SOURCE_RESOURCE_DIR)
            return cache.resourceDirs[resourceSourceIndex];
        else
            return ""Unknown"";
    }

    String GetFullPath()
    {
        return String(cache.resourceDirs[resourceSourceIndex] + resourceKey);
    }

    String GetPath()
    {
        return resourceKey;
    }

    void DetermainResourceType()
    {
        resourceType = GetResourceType(GetFullPath(), fileType, false);
        Text@ browserFileListRow_ = browserFileListRow.Get();
        if (browserFileListRow_ !is null)
        {
            InitializeBrowserFileListRow(browserFileListRow_, this);
        }
    }
    
    String ResourceTypeName()
    {
        return ::ResourceTypeName(resourceType);
    }

    void FileChanged()
    {
        if (!fileSystem.FileExists(GetFullPath()))
        {
        }
        else
        {
        }
    }
}

void CreateResourcePreview(String path, Node@ previewNode)
{
    resourceBrowserPreview.autoUpdate = false;
    int resourceType = GetResourceType(path); 
    if (resourceType > 0)
    {
        File file;
        file.Open(path);

        if (resourceType == RESOURCE_TYPE_MODEL)
        {
            Model@ model = Model();
            if (model.Load(file))
            {
                StaticModel@ staticModel = previewNode.CreateComponent(""StaticModel"");
                staticModel.model = model;
                return;
            }
        }
        else if (resourceType == RESOURCE_TYPE_MATERIAL)
        {
            Material@ material = Material();
            if (material.Load(file))
            {
                StaticModel@ staticModel = previewNode.CreateComponent(""StaticModel"");
                staticModel.model = cache.GetResource(""Model"", ""Models/Sphere.mdl"");
                staticModel.material = material;
                return;
            }
        }
        else if (resourceType == RESOURCE_TYPE_IMAGE)
        {
            Image@ image = Image();
            if (image.Load(file))
            {
                StaticModel@ staticModel = previewNode.CreateComponent(""StaticModel"");
                staticModel.model = cache.GetResource(""Model"", ""Models/Editor/ImagePlane.mdl"");
                Material@ material =  cache.GetResource(""Material"", ""Materials/Editor/TexturedUnlit.xml"");
                Texture2D@ texture = Texture2D();
                texture.SetData(@image, true);
                material.textures[0] = texture;
                staticModel.material = material;
                return;
            }
        }
        else if (resourceType == RESOURCE_TYPE_PREFAB)
        {
            if (GetExtension(path) == "".xml"")
            {
                XMLFile xmlFile;
                if(xmlFile.Load(file))
                    if(previewNode.LoadXML(xmlFile.root, true) && (previewNode.GetComponents(""StaticModel"", true).length > 0 || previewNode.GetComponents(""AnimatedModel"", true).length > 0))
                    {
                        return;
                    }
            }
            else if(previewNode.Load(file, true) && (previewNode.GetComponents(""StaticModel"", true).length > 0 || previewNode.GetComponents(""AnimatedModel"", true).length > 0))
                return;

            previewNode.RemoveAllChildren();
            previewNode.RemoveAllComponents();
        }
        else if (resourceType == RESOURCE_TYPE_PARTICLEEFFECT)
        {
            ParticleEffect@ particleEffect = ParticleEffect();
            if (particleEffect.Load(file))
            {
                ParticleEmitter@ particleEmitter = previewNode.CreateComponent(""ParticleEmitter"");
                particleEmitter.effect = particleEffect;
                particleEffect.activeTime = 0.0;
                particleEmitter.Reset();
                resourceBrowserPreview.autoUpdate = true;
                return;
            }
        }
    }

    StaticModel@ staticModel = previewNode.CreateComponent(""StaticModel"");
    staticModel.model = cache.GetResource(""Model"", ""Models/Editor/ImagePlane.mdl"");
    Material@ material =  cache.GetResource(""Material"", ""Materials/Editor/TexturedUnlit.xml"");
    Texture2D@ texture = Texture2D();
    Image@ noPreviewImage = cache.GetResource(""Image"", ""Textures/Editor/NoPreviewAvailable.png"");
    texture.SetData(noPreviewImage, false);
    material.textures[0] = texture;
    staticModel.material = material;

    return;
}

void RotateResourceBrowserPreview(StringHash eventType, VariantMap& eventData)
{
    int elemX = eventData[""ElementX""].GetInt();
    int elemY = eventData[""ElementY""].GetInt();
    
    if (resourceBrowserPreview.height > 0 && resourceBrowserPreview.width > 0)
    {
        float yaw = ((resourceBrowserPreview.height / 2) - elemY) * (90.0 / resourceBrowserPreview.height);
        float pitch = ((resourceBrowserPreview.width / 2) - elemX) * (90.0 / resourceBrowserPreview.width);

        resourcePreviewNode.rotation = resourcePreviewNode.rotation.Slerp(Quaternion(yaw, pitch, 0), 0.1);
        RefreshBrowserPreview();
    }
}

void RefreshBrowserPreview()
{
    resourceBrowserPreview.QueueUpdate();
}

class ResourceType
{
    int id;
    String name;
    ResourceType(int id_, String name_)
    {
        id = id_;
        name = name_;
    }
    int opCmp(ResourceType@ b)
    {
        return name.opCmp(b.name);
    }
}
",12478,False,2431.0702147883358,median
"/*

  IconMenu.ino
  
  This is an interactive demo and requires ""next"", ""prev"" and ""select"" button.
  Minimum height of the display should be 64.

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD0323_OS128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD0323_OS128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 		// Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); 	 // Not tested
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_MAX7219_64X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_32X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_8X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_LS013B7DH03_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V


// End of constructor list



void setup(void) {
  
  // DOGS102 Shield (http://shieldlist.org/controlconnection/dogs102)
  // u8g2.begin(/* menu_select_pin= */ 5, /* menu_next_pin= */ 4, /* menu_prev_pin= */ 2, /* menu_home_pin= */ 3);
  
  // DOGM128 Shield (http://shieldlist.org/schmelle2/dogm128) + DOGXL160 Shield
  // u8g2.begin(/* menu_select_pin= */ 2, /* menu_next_pin= */ 3, /* menu_prev_pin= */ 7, /* menu_home_pin= */ 8);

  // MKR Zero Test Board
  u8g2.begin(/*Select=*/ 0, /*Right/Next=*/ 1, /*Left/Prev=*/ 2, /*Up=*/ 4, /*Down=*/ 3, /*Home/Cancel=*/ A6); 

  // Arduboy
  //u8g2.begin(/*Select=*/ A0, /*Right/Next=*/ 5, /*Left/Prev=*/ 9, /*Up=*/ 8, /*Down=*/ 10, /*Home/Cancel=*/ A1); // Arduboy DevKit
  //u8g2.begin(/*Select=*/ 7, /*Right/Next=*/ A1, /*Left/Prev=*/ A2, /*Up=*/ A0, /*Down=*/ A3, /*Home/Cancel=*/ 8); // Arduboy 10 (Production)

  u8g2.setFont(u8g2_font_6x12_tr);
}

struct menu_entry_type
{
  const uint8_t *font;
  uint16_t icon;
  const char *name;
};

struct menu_state
{
  int16_t menu_start;		/* in pixel */
  int16_t frame_position;		/* in pixel */
  uint8_t position;			/* position, array index */
};

/*
  Icon configuration
  Width and height must match the icon font size
  GAP: Space between the icons
  BGAP: Gap between the display border and the cursor.
*/
#define ICON_WIDTH 32
#define ICON_HEIGHT 32
#define ICON_GAP 4
#define ICON_BGAP 16
#define ICON_Y 32+ ICON_GAP

struct menu_entry_type menu_entry_list[] =
{
  { u8g2_font_open_iconic_embedded_4x_t, 65, ""Clock Setup""},
  { u8g2_font_open_iconic_embedded_4x_t, 66, ""Gear Game""},
  { u8g2_font_open_iconic_embedded_4x_t, 67, ""Flash Light""},
  { u8g2_font_open_iconic_embedded_4x_t, 68, ""Home""},
  { u8g2_font_open_iconic_embedded_4x_t, 72, ""Configuration""},
  { NULL, 0, NULL } 
};

void draw(struct menu_state *state)
{
  int16_t x;
  uint8_t i;
  x = state->menu_start;
  i = 0;
  while( menu_entry_list[i].icon > 0 )  
  {
    if ( x >= -ICON_WIDTH && x < u8g2.getDisplayWidth() )
    {
      u8g2.setFont(menu_entry_list[i].font);
      u8g2.drawGlyph(x, ICON_Y, menu_entry_list[i].icon );
    }
    i++;
    x += ICON_WIDTH + ICON_GAP;
  }
  u8g2.drawFrame(state->frame_position-1, ICON_Y-ICON_HEIGHT-1, ICON_WIDTH+2, ICON_WIDTH+2);
  u8g2.drawFrame(state->frame_position-2, ICON_Y-ICON_HEIGHT-2, ICON_WIDTH+4, ICON_WIDTH+4);
  u8g2.drawFrame(state->frame_position-3, ICON_Y-ICON_HEIGHT-3, ICON_WIDTH+6, ICON_WIDTH+6);
}


void to_right(struct menu_state *state)
{
  if ( menu_entry_list[state->position+1].font != NULL )
  {
    if ( (int16_t)state->frame_position+ 2*(int16_t)ICON_WIDTH + (int16_t)ICON_BGAP < (int16_t)u8g2.getDisplayWidth() )
    {
      state->position++;
      state->frame_position += ICON_WIDTH + (int16_t)ICON_GAP;
    }
    else
    {
      state->position++;      
      state->frame_position = (int16_t)u8g2.getDisplayWidth() - (int16_t)ICON_WIDTH - (int16_t)ICON_BGAP;
      state->menu_start = state->frame_position - state->position*((int16_t)ICON_WIDTH + (int16_t)ICON_GAP);
    }
  }
}

void to_left(struct menu_state *state)
{
  if ( state->position > 0 )
  {
    if ( (int16_t)state->frame_position >= (int16_t)ICON_BGAP+(int16_t)ICON_WIDTH+ (int16_t)ICON_GAP )
    {
      state->position--;
      state->frame_position -= ICON_WIDTH + (int16_t)ICON_GAP;
    }    
    else
    {
      state->position--; 
      state->frame_position = ICON_BGAP;
      state->menu_start = state->frame_position - state->position*((int16_t)ICON_WIDTH + (int16_t)ICON_GAP);
      
    }
  }
}


uint8_t towards_int16(int16_t *current, int16_t dest)
{
  if ( *current < dest )
  {
    (*current)++;
    return 1;
  }
  else if ( *current > dest )
  {
    (*current)--;
    return 1;
  }
  return 0;
}

uint8_t towards(struct menu_state *current, struct menu_state *destination)
{
  uint8_t r = 0;
  r |= towards_int16( &(current->frame_position), destination->frame_position);
  r |= towards_int16( &(current->frame_position), destination->frame_position);
  r |= towards_int16( &(current->menu_start), destination->menu_start);
  r |= towards_int16( &(current->menu_start), destination->menu_start);
  return r;
}



struct menu_state current_state = { ICON_BGAP, ICON_BGAP, 0 };
struct menu_state destination_state = { ICON_BGAP, ICON_BGAP, 0 };

void loop(void) {
  int8_t event;

  do
  {
    u8g2.clearBuffer();
    draw(&current_state);  
    u8g2.setFont(u8g2_font_helvB10_tr);  
    u8g2.setCursor((u8g2.getDisplayWidth()-u8g2.getStrWidth(menu_entry_list[destination_state.position].name))/2,u8g2.getDisplayHeight()-5);
    u8g2.print(menu_entry_list[destination_state.position].name);    
    u8g2.sendBuffer();
    delay(10);
    event = u8g2.getMenuEvent();
    if ( event == U8X8_MSG_GPIO_MENU_NEXT )
      to_right(&destination_state);
    if ( event == U8X8_MSG_GPIO_MENU_PREV )
      to_left(&destination_state);
    if ( event == U8X8_MSG_GPIO_MENU_SELECT )
    {
      u8g2.setFont(u8g2_font_helvB10_tr);  
      u8g2.userInterfaceMessage(""Selection:"", menu_entry_list[destination_state.position].name, """", "" Ok "");
    }
  } while ( towards(&current_state, &destination_state) );
}
",16368,True,4370.697759236356,median
"/*

  ScrollingText.ino

  This will scroll text on the display. 
  Enable U8g2 16 bit mode (see FAQ) for larger text!

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U82glib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.
  
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


// This example shows a scrolling text.
// If U8G2_16BIT is not set (default), then the pixel width of the text must be lesser than 128
// If U8G2_16BIT is set, then the pixel width an be up to 32000 


u8g2_uint_t offset;			// current offset for the scrolling text
u8g2_uint_t width;			// pixel width of the scrolling text (must be lesser than 128 unless U8G2_16BIT is defined
const char *text = ""U8g2 "";	// scroll this text from right to left


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  u8g2.begin();  
  
  u8g2.setFont(u8g2_font_inb30_mr);	// set the target font to calculate the pixel width
  width = u8g2.getUTF8Width(text);		// calculate the pixel width of the text
  
  u8g2.setFontMode(0);		// enable transparent mode, which is faster
}


void loop(void) {
  u8g2_uint_t x;
  
  u8g2.firstPage();
  do {
  
    // draw the scrolling text at current offset
    x = offset;
    u8g2.setFont(u8g2_font_inb30_mr);		// set the target font
    do {								// repeated drawing of the scrolling text...
      u8g2.drawUTF8(x, 30, text);			// draw the scolling text
      x += width;						// add the pixel width of the scrolling text
    } while( x < u8g2.getDisplayWidth() );		// draw again until the complete display is filled
    
    u8g2.setFont(u8g2_font_inb16_mr);		// draw the current pixel width
    u8g2.setCursor(0, 58);
    u8g2.print(width);					// this value must be lesser than 128 unless U8G2_16BIT is set
    
  } while ( u8g2.nextPage() );
  
  offset-=1;							// scroll by one pixel
  if ( (u8g2_uint_t)offset < (u8g2_uint_t)-width )	
    offset = 0;							// start over again
    
  delay(10);							// do some small delay
}

",16275,True,4935.0773880166125,median
"#include ""Arduino.h""
#include <FastLED.h>
#include <FastLEDPainter.h>
#include <EEPROM.h>
#include <CircularBuffer.h>

/*
 * Utilizing FastLED painter libary and some animations from Damian Schneider.
 */

/*
 * LED animation members, constants, headers
 */
const int duration = 1000; //number of loops to run each animation for

#if FASTLED_VERSION < 3001000
#error ""Requires FastLED 3.1 or later; check github for latest code.""
#endif

// Fixed definitions cannot change on the fly.
#define LED_DT 4                                             // Data pin to connect to the strip. For APA strips this generally the GREEN wire.
#define LED_CK 5                                             // For APA strips this generally the YELLOW wire.
#define COLOR_ORDER BGR                                      // Are they RGB, GRB or what??
#define LED_TYPE APA102                                      // Don't forget to change LEDS.addLeds
#define NUM_LEDS 144                                         //Number of LEDs on the strip

// Initialize changeable global variables.
uint8_t max_bright = 128;                                     // Overall brightness definition. It can be changed on the fly.

struct CRGB leds[NUM_LEDS];

//create one canvas and one brush with global scope
FastLEDPainterCanvas pixelcanvas = FastLEDPainterCanvas(NUM_LEDS); //create canvas, linked to the FastLED library (canvas must be created before the brush)
FastLEDPainterBrush pixelbrush = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to

// FOR BOUNCY BALLS ANIMATION
//create additional brushes, painting on the same canvas as the globally defined brush 
FastLEDPainterBrush pixelbrushBB2 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to
FastLEDPainterBrush pixelbrushBB3 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to

/*
 * I2C members, constants and headers
 */
#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards
#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)


#include <NXPMotionSense.h>
NXPMotionSense imu;
NXPSensorFusion filter;


#include ""I2Cdev.h""
#include ""MPU6050_6Axis_MotionApps20.h""
//#include ""MPU6050.h"" // not necessary if using MotionApps include file

// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
// is used in I2Cdev.h
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
    #include ""Wire.h""
#endif

// default I2C address is 0x68
MPU6050 mpu;

// uncomment ""OUTPUT_READABLE_YAWPITCHROLL"" if you want to see the yaw/
// pitch/roll angles (in degrees) calculated from the quaternions coming
// from the FIFO. Note this also requires gravity vector calculations.
// Also note that yaw/pitch/roll angles suffer from gimbal lock (for
// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock)
#define OUTPUT_READABLE_YAWPITCHROLL
const bool DEBUG_OUTPUT = true;
const bool YAW_ANIMATION_CONTROL = false;
const uint8_t DIAL_SENSITIVITY = 35;
const uint8_t ADDRESS_ANIMATION_NUM = 0;
const uint8_t ANIMATION_COUNT = 4;

bool blinkState = false;
uint8_t YAW = 2;
uint8_t ROLL = 1;
uint8_t speedController = ROLL;
uint8_t secondaryController = YAW;
bool dynamiclyAssignMotionControls = false;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion qc;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector
// CircularBuffer<int, 100> rollHistory;
unsigned long time = 0;
float roll_rate = 0.0;  // roll rate
float old_roll_rate = 0.0;  // roll rate
const float ROLL_THRESHOLD = 15.0;
bool spinning_animation = false;

uint8_t randomShow;
uint8_t animationNumber;
uint16_t programNotch;
static signed int speed = 1;
static signed int lastSpeed = speed;
byte eprom;

//static unsigned int hue = 0; //color hue to set to brush
CHSV brushcolor; //HSV color definition

// ================================================================
// ===               INTERRUPT DETECTION ROUTINE                ===
// ================================================================

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
        mpuInterrupt = true;
}


void setup() {
        delay(1000);      // sanity check delay

        // put your setup code here, to run once:
        // LEDS.addLeds<LED_TYPE, LED_DT, LED_CK, COLOR_ORDER>(leds, NUM_LEDS); // Use this for WS2801 or APA102

        FastLED.addLeds<LED_TYPE, COLOR_ORDER>(leds, NUM_LEDS);
        pinMode(7, OUTPUT);
        digitalWrite(7, HIGH);

        //setupI2C();

        // initI2C();
        // readMpu();
        time = millis();
        
        setupPropShield();
        readPropShield();

        setupLedAnimations();
        randomShow = random(10);
        Serial.print(""random number is:"");
        Serial.print(randomShow);
        Serial.print(""\\n"");

        // reading EEPROM persisted animation number
        animationNumber = EEPROM.read(ADDRESS_ANIMATION_NUM);
        Serial.print(""ANIMATION EEPROM :"");
        Serial.print(animationNumber);
        Serial.print(""\\n"");

        if(!YAW_ANIMATION_CONTROL)
                saveAnimationNum((animationNumber + 1) % ANIMATION_COUNT);

        if(DEBUG_OUTPUT)
                delay(200); //delay so serial interface on teensy can be created (it's a virtual interface)

        if(dynamiclyAssignMotionControls)
                initDynamicControlsDuringBatteryCheck();
        else
                batteryCheck();
}

// Animation
void blink(float voltage) {
        int blinkCount = 0;
        if(voltage > 4.2)
                blinkCount = 5;
        else if(voltage > 4.0)
                blinkCount = 4;
        else if(voltage > 3.8)
                blinkCount = 3;
        else if(voltage > 3.6)
                blinkCount = 2;
        else if(voltage > 3.4)
                blinkCount = 1;

        for(int i = 0; i < blinkCount; i++) {
                pixelbrush.setFadeSpeed(90);
                pixelbrush.setFadein(false); //brightness will fade-in if set to true
                pixelbrush.setFadeout(true);
                pixelbrush.setBounce(false);

                pixelbrush.setSpeed(0); //brush moving speed

                brushcolor.s = 255; //full saturation
                int brightness = 255;
                brushcolor.v = brightness; //random (peak) brighness

                pixelbrush.setColor(brushcolor); //set new color to the bursh

                FastLED.clear();
                FastLED.show();
                delay(200);

                pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
                delay(200);
        }
}

void batteryCheck() {
        int sensorValue = analogRead(A0); //read the A0 pin value
        float voltage = sensorValue * (5.00 / 1600.00) * 2; //convert the value to a true voltage.
        Serial.print(""voltage = "");
        Serial.print(voltage);
        Serial.println("" V"");

        blink(voltage); //blinks indicating approximate battery level
}

// Allows one to orient the stave in position one would like to have as primary speed controller
// during the battery check led animation.
void initDynamicControlsDuringBatteryCheck() {

        int sensorValue = analogRead(A0); //read the A0 pin value
        float voltage = sensorValue * (5.00 / 1600.00) * 2; //convert the value to a true voltage.
        Serial.print(""voltage = "");
        Serial.print(voltage);
        Serial.println("" V"");

        // Part 1 take initial readings
        readMpu(); //throw out first one.
        readMpu();
        float yaw = ypr[0] * 180/M_PI;
        float pitch = ypr[1] * 180/M_PI;
        float roll = ypr[2] * 180/M_PI;

        blink(voltage); //blinks indicating approximate battery level

        // Part 2 take final readings post battery animation
        readMpu();
        float yaw_later = ypr[0] * 180/M_PI;
        float pitch_later = ypr[1] * 180/M_PI;
        float roll_later = ypr[2] * 180/M_PI;

        // the one with the biggest difference is now the main speed controller
        float y_diff = abs(yaw - yaw_later);
        float r_diff = abs(roll - roll_later);

        if(DEBUG_OUTPUT) {
                Serial.print(""yaw diff: "");
                Serial.print(y_diff);
                Serial.print(""   roll diff: "");
                Serial.println(r_diff);
        }
        if(y_diff > r_diff)
                speedController = YAW;
        else
                speedController = ROLL;

        if(DEBUG_OUTPUT) {
                if(speedController == ROLL)
                        Serial.println(""speedController: ROLL"");
                else if(speedController == YAW)
                        Serial.println(""speedController: YAW"");
        }
}

// ================================================================
// ===                      INITIAL I2C SETUP                   ===
// ================================================================
void setupI2C()
{

        // join I2C bus (I2Cdev library doesn't do this automatically)
    #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
        Wire.begin();
        Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
    #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
        Fastwire::setup(400, true);
    #endif

        // initialize serial communication
        // (115200 chosen because it is required for Teapot Demo output, but it's
        // really up to you depending on your project)
        Serial.begin(115200);
        while (!Serial); // wait for Leonardo enumeration, others continue immediately

        // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio
        // Pro Mini running at 3.3v, cannot handle this baud rate reliably due to
        // the baud timing being too misaligned with processor ticks. You must use
        // 38400 or slower in these cases, or use some kind of external separate
        // crystal solution for the UART timer.

        // initialize device
        Serial.println(F(""Initializing I2C devices...""));
        mpu.initialize();
        pinMode(INTERRUPT_PIN, INPUT);

        // verify connection
        Serial.println(F(""Testing device connections...""));
        Serial.println(mpu.testConnection() ? F(""MPU6050 connection successful"") : F(""MPU6050 connection failed""));

        // wait for ready
        Serial.println(F(""\\nSend any character to begin DMP programming and demo: ""));
//    while (Serial.available() && Serial.read()); // empty buffer
// while (!Serial.available());                 // wait for data
//   while (Serial.available() && Serial.read()); // empty buffer again

        // load and configure the DMP
        Serial.println(F(""Initializing DMP...""));
        devStatus = mpu.dmpInitialize();

        // supply your own gyro offsets here, scaled for min sensitivity
        mpu.setXGyroOffset(220);
        mpu.setYGyroOffset(76);
        mpu.setZGyroOffset(-85);
        mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

        // make sure it worked (returns 0 if so)
        if (devStatus == 0) {
                // turn on the DMP, now that it's ready
                Serial.println(F(""Enabling DMP...""));
                mpu.setDMPEnabled(true);

                // enable Arduino interrupt detection
                Serial.println(F(""Enabling interrupt detection (Arduino external interrupt 0)...""));
                //attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING);
                //mpuIntStatus = mpu.getIntStatus();
                mpuIntStatus = 1;
                // set our DMP Ready flag so the main loop() function knows it's okay to use it
                Serial.println(F(""DMP ready! Waiting for first interrupt...""));
                dmpReady = true;

                // get expected DMP packet size for later comparison
                packetSize = mpu.dmpGetFIFOPacketSize();
        } else {
                // ERROR!
                // 1 = initial memory load failed
                // 2 = DMP configuration updates failed
                // (if it's going to break, usually the code will be 1)
                Serial.print(F(""DMP Initialization failed (code ""));
                Serial.print(devStatus);
                Serial.println(F("")""));
        }

        Serial.print(F(""after the interupt wait...""));
        // configure LED for output
        pinMode(LED_PIN, OUTPUT);
}

void setupLedAnimations()
{
        randomSeed(analogRead(0)); //new random seed

        FastLED.show();

        Serial.begin(115200);
        Serial.println("" "");
        Serial.println(""Ray's rave stave begin"");

        //check if ram allocation of brushes and canvases was successful (painting will not work if unsuccessful, program should still run though)
        //this check is optional but helps to check if something does not work, especially on low ram chips like the Arduino Uno
        if (pixelcanvas.isvalid() == false) Serial.println(""canvas allocation problem"");
        else Serial.println(""canvas allocation ok"");


        if (pixelbrush.isvalid() == false) Serial.println(""brush allocation problem"");
        else Serial.println(""brush allocation ok"");

        brushcolor.h = random(255); //random color
        brushcolor.s = 255; //full saturation
        brushcolor.v = 255; //full brightness
}

unsigned long loopcounter; //count the loops, switch to next animation after a while
bool initialized = false; //initialize the canvas & brushes in each loop when zero

void loop()
{
        //ledAnimationBundle();
        //blink();
        doUserInput(); // side steps the random show choice! FYI loops on itself

        if( randomShow >7)
        {
                doUserInput();
        }
        else if(randomShow>=4 && randomShow<=6)
        {
                doSlowAnimations();
        }
        else
        {
                ledAnimationBundle();
        }

}

void doSlowAnimations()
{

        while(true)
        {
                initialized = false;
                twinkleStars();
                initialized = false;
                hueDemo();
                initialized = false;
                twoBrushColorMixing();
        }

}

void doUserInput()
{
        // initI2C();
        // readMpu();

        setupPropShield();
        readPropShield();

        if(YAW_ANIMATION_CONTROL) {
                float yaw = ypr[0] * 180/M_PI;
                float pitch = ypr[1] * 180/M_PI;
                float roll = ypr[2] * 180/M_PI;
                programNotch = abs(yaw);
                Serial.print(""programNotch: "");
                Serial.print(programNotch);
        }

        while(true)
        {
                doLeds();
        }

}

void doLeds()
{
        initialized = false;

        // readMpu();
        readPropShield();

        float yaw = ypr[0] * 180/M_PI;
        float pitch = ypr[1] * 180/M_PI;
        float roll = ypr[2] * 180/M_PI;

        if(YAW_ANIMATION_CONTROL)
        {
                int programNotchNow = abs(yaw);
                if(abs(programNotchNow - programNotch) > DIAL_SENSITIVITY) {

                        programNotch = abs(yaw);
                        animationNumber = (++animationNumber)%3;
                        saveAnimationNum(animationNumber);
                        if(DEBUG_OUTPUT) {
                                Serial.print(""new programNotch: "");
                                Serial.print(programNotch);
                                Serial.print("" new animationNumber: "");
                                Serial.print(animationNumber);
                        }
                }
        }
        //raindbowPaint();
        // bouncyBalls();
        // initialized = false;
        //sparkler();
        //twoBrushColorMixing();
        if(DEBUG_OUTPUT) {
                // Serial.print(""\\nanimationNumber: "");
                // Serial.print(animationNumber);
                // Serial.print("" "");
        }

        // Dynamic user input animations
        if (animationNumber % ANIMATION_COUNT ==  0) {
                dripRead();
        }
        else if (animationNumber % ANIMATION_COUNT ==  1) {
                rainbowPaintRead();
        }
        else if (animationNumber % ANIMATION_COUNT ==  2) {
                sparklerFireRead(10, false);
        }
        else {
                sparklerRead();
        }
        
        // Static fire animations
        // if (animationNumber % ANIMATION_COUNT ==  0) {
        //         sparklerFireRead(10, false);
        // }
        // else if (animationNumber % ANIMATION_COUNT ==  1) {
        //         sparklerFireRead(10, true);
        // }
        // else if (animationNumber % ANIMATION_COUNT ==  2) {
        //         sparklerFireRead(125, false);
        // }
        // else {
        //         sparklerFireRead(125, true);
        // }

        if(DEBUG_OUTPUT && YAW_ANIMATION_CONTROL) {
                Serial.print(""next programNotch [ "");
                Serial.print(programNotch - DIAL_SENSITIVITY);
                Serial.print("" <-> "");
                Serial.print(programNotch + DIAL_SENSITIVITY);
                Serial.print("" ]\\n"");
        }
}

void saveAnimationNum(int number) {
        EEPROM.write(ADDRESS_ANIMATION_NUM, number);
}

// Animation
void dripRead()
{
        // Serial.print(F(""in dripRead\\n""));

        if (initialized == false) //initialize the brushes
        {
                initialized = true;
                pixelbrush.setFadeSpeed(90);
                pixelbrush.setFadein(false); //brightness will fade-in if set to true
                pixelbrush.setFadeout(true);
                pixelbrush.setBounce(false);
        }

        // float yaw = ypr[0] * 180/M_PI;
        // float pitch = ypr[1] * 180/M_PI;
        // float roll = ypr[2] * 180/M_PI;

        float yaw = ypr[0];
        float pitch = ypr[1];
        float roll = ypr[2];  

        updateSpeed(5);

        if(speed > 0 && lastSpeed < 0 ||
           speed < 0 && lastSpeed > 0) {
                brushcolor.h = random(255); //random color
        }

        pixelbrush.setSpeed(speed); //brush moving speed

        brushcolor.s = 255; //full saturation

        // int brightness = 125 - abs(pitch) * 2.8; //TODO configure the brightness according the secondaryController global var
        int brightness = int(abs(yaw)) % 120; //TODO configure the brightness according the secondaryController global var

        brushcolor.v = brightness; //random (peak) brighness

        pixelbrush.setColor(brushcolor); //set new color to the bursh

        FastLED.clear();

        pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
        pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

        if (DEBUG_OUTPUT) {
                printInfo(brightness);
                // Serial.print(""speed: "");
                // Serial.print(speed);
                // if(speedController == ROLL)
                //         Serial.println("" speedController: ROLL"");
                // else if(speedController == YAW)
                //         Serial.println("" speedController: YAW"");
                // Serial.print(""\\nbrightness: "");
                // Serial.print(brightness);
                // Serial.print(""\\n"");
        }

        FastLED.show();
}

void printInfo(int brightness) {
        // char buf[10];
        // sprintf(buf, ""speed %d"", speed)
        // Serial.println(buf);

        // Serial.print(""speed: "");
        // Serial.print(speed);
        // Serial.print(""   brightness: "");
        // Serial.print(brightness);
        // if(speedController == ROLL)
        //         Serial.print(""   speedController: ROLL"");
        // else if(speedController == YAW)
        //         Serial.println(""   speedController: YAW"");

        // float roll, pitch, yaw;
        // roll = filter.getRoll();
        // pitch = filter.getPitch();
        // yaw = filter.getYaw();
        // Serial.print("" yaw: "");
        // Serial.print(yaw);
        // Serial.print("" pitch: "");
        // Serial.print(pitch);
        // Serial.print("" roll: "");
        // Serial.println(roll);
        
        // Serial.print(""\\n"");
}

void printInfo2(int brightness) {

        Serial.print(""speed: "");
        Serial.print(speed);
        Serial.print(""   brightness: "");
        Serial.print(brightness);
        if(speedController == ROLL)
                Serial.print(""   speedController: ROLL"");
        else if(speedController == YAW)
                Serial.println(""   speedController: YAW"");

        float roll, pitch, yaw;
        roll = filter.getRoll();
        pitch = filter.getPitch();
        yaw = filter.getYaw();
        Serial.print("" yaw: "");
        Serial.print(yaw);
        Serial.print("" pitch: "");
        Serial.print(pitch);
        Serial.print("" roll: "");
        Serial.println(roll);
        
        Serial.print(""\\n"");
}

void ledAnimationBundle()
{
        while(true)
        {
                initialized = false;
                rainbowPaint();
                initialized = false;
                sparkler(); // fast shooting white balls
                initialized = false;
                twinkleStars(); // not good for motion control
                initialized = false;
                chaser(); // low surface area dark chaser
                initialized = false;
                hueDemo(); //maybe brightness?
                initialized = false;
                speedTrails(); //great for motion roll
                initialized = false;
                bouncyBalls();
                initialized = false;
                twoBrushColorMixing();
        }

}

void rainbowBlink()
{
        Serial.println(F(""rainbow blink""));
        //the brush moves along the strip, leaving a colorful rainbow trail
        for(loopcounter = 0; loopcounter<100; loopcounter++)
        {
                static unsigned int hue = 0; //color hue to set to brush
                //CHSV brushcolor; //HSV color definition


                if (initialized == false) //initialize the brushes
                {
                        initialized = true;
                        pixelbrush.setSpeed(random(200) + 200); //brush moving speed
                        pixelbrush.setFadeSpeed(90);
                        pixelbrush.setFadein(false); //brightness will fade-in if set to true
                        pixelbrush.setFadeout(true);
                        pixelbrush.setBounce(false);
                }

                hue++;
                brushcolor.h = hue / 3; //divide by 3 to slow down color fading
                brushcolor.s = 255; //full saturation
                brushcolor.v = 125; //full brightness

                pixelbrush.setColor(brushcolor); //set new color to the bursh

                FastLED.clear();

                pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
        }

}

//---------------------
//RAINBOW PAINT (aka nyan cat)
//---------------------
// Animation
void rainbowPaintRead()
{
        // Serial.println(F(""in rainbow paint read""));
        //the brush moves along the strip, leaving a colorful rainbow trail
        // for(loopcounter = 0; loopcounter<duration; loopcounter++)
        // {
        static unsigned int hue = 0; //color hue to set to brush


        if (initialized == false) //initialize the brushes
        {
                initialized = true;
                pixelbrush.setSpeed(speed); //brush moving speed
                pixelbrush.setFadeSpeed(90);
                pixelbrush.setFadein(false); //brightness will fade-in if set to true
                pixelbrush.setFadeout(true);
                pixelbrush.setBounce(false);
        }

        // float yaw = ypr[0] * 180/M_PI;
        // float pitch = ypr[1] * 180/M_PI;
        // float roll = ypr[2] * 180/M_PI;

        float yaw = ypr[0];
        float pitch = ypr[1];
        float roll = ypr[2];  

        updateSpeed(5);
        pixelbrush.setSpeed(speed); //brush moving speed

        hue++;
        brushcolor.h = hue / 3; //divide by 3 to slow down color fading
        brushcolor.s = 255; //full saturation

        // int brightness = 125 - abs(pitch) * 2.8; //TODO configure the brightness according the secondaryController global var
        int brightness = int(abs(yaw)) % 120; //TODO configure the brightness according the secondaryController global var
        
        brushcolor.v = brightness; //random (peak) brighness
        //brushcolor.v = 255; //full brightness

        pixelbrush.setColor(brushcolor); //set new color to the bursh

        FastLED.clear();

        pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
        pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

        if (DEBUG_OUTPUT) {
                printInfo(brightness);
                // Serial.print(""speed: "");
                // Serial.print(speed);
                // if(speedController == ROLL)
                //         Serial.println("" speedController: ROLL"");
                // else if(speedController == YAW)
                //         Serial.println("" speedController: YAW"");
                // Serial.print(""\\nbrightness: "");
                // Serial.print(brightness);
                // Serial.print(""\\n"");
        }

        FastLED.show();
        // }
}
//---------------------
//RAINBOW PAINT (aka nyan cat)
//---------------------
// Animation
void rainbowPaint()
{
        Serial.println(F(""rainbow paint""));
        //the brush moves along the strip, leaving a colorful rainbow trail
        for(loopcounter = 0; loopcounter<duration; loopcounter++)
        {
                static unsigned int hue = 0; //color hue to set to brush
                //CHSV brushcolor; //HSV color definition


                if (initialized == false) //initialize the brushes
                {
                        initialized = true;
                        pixelbrush.setSpeed(random(200) + 200); //brush moving speed
                        pixelbrush.setFadeSpeed(90);
                        pixelbrush.setFadein(false); //brightness will fade-in if set to true
                        pixelbrush.setFadeout(true);
                        pixelbrush.setBounce(false);
                }

                hue++;
                brushcolor.h = hue / 3; //divide by 3 to slow down color fading
                brushcolor.s = 255; //full saturation
                brushcolor.v = 255; //full brightness

                pixelbrush.setColor(brushcolor); //set new color to the bursh

                FastLED.clear();

                pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
        }
}

void rainbowPaintWithInput()
{
        Serial.println(F(""rainbow paint with input""));
        //the brush moves along the strip, leaving a colorful rainbow trail
        for(loopcounter = 0; loopcounter<duration; loopcounter++)
        {
                readPropShield(); // still want the averages to update

                static unsigned int hue = 0; //color hue to set to brush
                //CHSV brushcolor; //HSV color definition


                if (initialized == false) //initialize the brushes
                {
                        initialized = true;
                        pixelbrush.setSpeed(random(100) + 300); //brush moving speed
                        pixelbrush.setFadeSpeed(90);
                        pixelbrush.setFadein(false); //brightness will fade-in if set to true
                        pixelbrush.setFadeout(true);
                        pixelbrush.setBounce(false);
                }

                hue++;
                brushcolor.h = hue / 3; //divide by 3 to slow down color fading
                brushcolor.s = 255; //full saturation
                // brushcolor.v = 255; //full brightness
                brushcolor.v = 155; //full brightness

                // float yaw = ypr[0];
                // int brightness = (int(abs(yaw)) % 120) + 50;
                // brushcolor.v = brightness; 
                

                pixelbrush.setColor(brushcolor); //set new color to the bursh

                FastLED.clear();

                pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
        }

        spinning_animation = false;
}

void updateSpeed(int multiplier)
{
        // float yaw = ypr[0] * 180/M_PI;
        // float pitch = ypr[1] * 180/M_PI;
        // float roll = ypr[2] * 180/M_PI;

        float yaw = ypr[0];
        float pitch = ypr[1];
        float roll = ypr[2];        

        if(speedController == ROLL) {
                lastSpeed = speed;
                speed = roll * multiplier;
        }
        else {
                lastSpeed = speed;
                speed = yaw * multiplier;
        }
}

// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames.  More cooling = shorter flames.
// Default 50, suggested range 20-100 
#define COOLING  55

// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
#define SPARKING 120
bool gReverseDirection = false;

void sparklerFireReadOg()
{
// Array of temperature readings at each simulation cell
  static byte heat[NUM_LEDS];

  // Step 1.  Cool down every cell a little
    for( int i = 0; i < NUM_LEDS; i++) {
      heat[i] = qsub8( heat[i],  random8(0, ((COOLING * 10) / NUM_LEDS) + 2));
    }
  
    // Step 2.  Heat from each cell drifts 'up' and diffuses a little
    for( int k= NUM_LEDS - 1; k >= 2; k--) {
      heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;
    }
    
    // Step 3.  Randomly ignite new 'sparks' of heat near the bottom
    if( random8() < SPARKING ) {
      int y = random8(7);
      heat[y] = qadd8( heat[y], random8(160,255) );
    }

    // Step 4.  Map from heat cells to LED colors
    for( int j = 0; j < NUM_LEDS; j++) {
      CRGB color = HeatColor( heat[j]);
      int pixelnumber;
      if( gReverseDirection ) {
        pixelnumber = (NUM_LEDS-1) - j;
      } else {
        pixelnumber = j;
      }
      leds[pixelnumber] = color;
    }

    FastLED.show(); // display this frame
}

void sparklerFireRead(uint8_t fireBrightness, bool reverse)
{
// Array of temperature readings at each simulation cell
  static byte heat[NUM_LEDS];

  // Step 1.  Cool down every cell a little
    for( int i = 0; i < NUM_LEDS; i++) {
      heat[i] = qsub8( heat[i],  random8(0, ((COOLING * 10) / NUM_LEDS) + 2));
    }
  
    // Step 2.  Heat from each cell drifts 'up' and diffuses a little
    for( int k= NUM_LEDS - 1; k >= 2; k--) {
      heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;
    }
    
    // Step 3.  Randomly ignite new 'sparks' of heat near the bottom
    if( random8() < SPARKING ) {
      int y = random8(7);
      heat[y] = qadd8( heat[y], random8(100,255) );
    }

     // Step 4.  Map from heat cells to LED colors
    for( int j = 0; j < NUM_LEDS; j++) {
      // Scale the heat value from 0-255 down to 0-240
      // for best results with color palettes.
      byte colorindex = scale8( heat[j], 240);
      CRGB color = ColorFromPalette( CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::Orange,  CRGB::BlueViolet), colorindex, fireBrightness);
      if (reverse) {
        color = ColorFromPalette( CRGBPalette16( CRGB::BlueViolet,  CRGB::Orange, CRGB::Red, CRGB::Black), colorindex, fireBrightness);
      }

      int pixelnumber;
      if( gReverseDirection ) {
        pixelnumber = (NUM_LEDS-1) - j;
      } else {
        pixelnumber = j;
      }
      leds[pixelnumber] = color;
    }

    FastLED.show(); // display this frame
}

//SPARKLER: a brush seeding sparkles
// Animation
void sparklerRead()
{
        // Serial.print(F(""in sparklerRead\\n""));

        // float yaw = ypr[0] * 180/M_PI;
        // float pitch = ypr[1] * 180/M_PI;
        // float roll = ypr[2] * 180/M_PI;

        float yaw = ypr[0];
        float pitch = ypr[1];
        float roll = ypr[2];  

        //updateSpeed(roll * 5 + 600);
        if (initialized == false)
        {
                initialized = true;
                updateSpeed(5);
                pixelbrush.setSpeed(speed);
                // if(speed > 0)
                //   pixelbrush.setSpeed(600);
                // else
                //   pixelbrush.setSpeed(-600);
                pixelbrush.setFadeout(true);   //sparkles fade in
                pixelbrush.setFadein(true);   //and fade out immediately after reaching the set brightness
        }



        int saturation = 255 - abs(yaw) * 2.8;

        //set a new brush color in each loop
        brushcolor.h = random(255);   //random color
        brushcolor.s = saturation;  //random(130); //random but low saturation, giving white-ish sparkles
        int brightness = random(125);
        brushcolor.v = brightness;                //random (peak) brighness

        pixelbrush.setColor(brushcolor);
        pixelbrush.setFadeSpeed(random(100) + 150);   //set a new fadespeed with some randomness

        FastLED.clear();

        pixelbrush.paint();   //paint the brush to the canvas (and update the brush, i.e. move it a little)
        pixelcanvas.transfer();   //transfer (add) the canvas to the FastLED

        if (DEBUG_OUTPUT) {
                printInfo(brightness);
                // Serial.print(""speed: "");
                // Serial.print(speed);
                // if(speedController == ROLL)
                //         Serial.println("" speedController: ROLL"");
                // else if(speedController == YAW)
                //         Serial.println("" speedController: YAW"");
                // Serial.print(""\\nsaturation: "");
                // Serial.print(saturation);
                // Serial.print(""\\n"");
        }

        FastLED.show();

}

//SPARKLER: a brush seeding sparkles
// Animation
void sparkler()
{
        Serial.println(F(""sparkler""));
        for(loopcounter = 0; loopcounter<duration; loopcounter++)
        {

                //CHSV brushcolor;

                if (initialized == false)
                {
                        initialized = true;
                        pixelbrush.setSpeed(600);
                        pixelbrush.setFadeout(true); //sparkles fade in
                        pixelbrush.setFadein(true); //and fade out immediately after reaching the set brightness
                }

                //set a new brush color in each loop
                brushcolor.h = random(255); //random color
                brushcolor.s = random(130); //random but low saturation, giving white-ish sparkles
                brushcolor.v = random(200); //random (peak) brighness

                pixelbrush.setColor(brushcolor);
                pixelbrush.setFadeSpeed(random(100) + 150); //set a new fadespeed with some randomness

                FastLED.clear();

                pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
        }
}

//---------------------
//TWINKLE STARS
//---------------------
// Animation
void twinkleStars()
{
        Serial.println(F(""twinkler stars""));
        //brush set to random positions and painting a fading star
        for(loopcounter = 0; loopcounter<duration; loopcounter++)
        {

                //CHSV brushcolor;

                if (initialized == false)
                {
                        initialized = true;
                        pixelbrush.setSpeed(0); //do not move automatically
                        pixelbrush.setFadein(true); //fade in
                        pixelbrush.setFadeout(true); //and fade out
                }


                if (rand() % 100 == 0) //at a random interval, move the brush to paint a new pixel (brush only paints a new pixel once)
                {
                        brushcolor.h = rand();
                        brushcolor.s = random(40); //set low saturation, almost white
                        brushcolor.v = random(200) + 20; //set random brightness
                        pixelbrush.setColor(brushcolor);
                        pixelbrush.moveTo(random(NUM_LEDS)); //move the brush to a new, random pixel
                        pixelbrush.setFadeSpeed(random(10) + 5); //set random fade speed, minimum of 5
                }

                //add a background color by setting all pixels to a color (instead of clearing all pixels):
                fill_solid(leds, NUM_LEDS, CRGB(1, 0, 6)); //color in RGB: dark blue


                pixelbrush.paint(); //paint the brush to the canvas
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
        }
}

//-------------
//CHASER
//-------------
// Animation
void chaser()
{
        Serial.println(F(""chaser""));

        // two brushes chasing each other, one painting the pixel in a color, the other one painting 'black' (acting on the same canvas)

        while(true) //create a loop with an additional brush (is deleted automatically once the loop finishes)
        {

                //create an additional brush, painting on the same canvas as the globally defined brush
                FastLEDPainterBrush pixelbrush2 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to

                if (pixelbrush2.isvalid() == false) Serial.println(F(""brush2 allocation problem""));
                else Serial.println(F(""brush2 allocation ok""));


                for(loopcounter = 0; loopcounter<duration; loopcounter++)
                {


                        if (initialized == false)
                        {
                                //CHSV brushcolor;

                                initialized = true;

                                brushcolor.h = random(255); //choose random color once
                                brushcolor.s = 255; //full staturation
                                brushcolor.v = 150;

                                //initialize the first brush to move and paint a color, no fading
                                pixelbrush.setSpeed(300); //moving speed was 900 but too fast for teensy
                                pixelbrush.setColor(brushcolor);
                                pixelbrush.setFadeout(false); //deactivate fade-out (was activated in last animation)
                                pixelbrush.setFadein(false); //deactivate fade-in
                                pixelbrush2.moveTo(0); //move the brush to pixel 0
                                //initialize the second brush to move at the same speed but starting at a different position (default position is 0)
                                brushcolor.v = 0; //zero intensity = black
                                pixelbrush2.setSpeed(300); //moving speed was 900 but too fast for teensy
                                pixelbrush2.setColor(brushcolor);
                                pixelbrush2.moveTo(2*NUM_LEDS/3); //move the brush

                        }

                        FastLED.clear();

                        pixelbrush.paint(); //apply the paint of the first brush to the canvas (and update the brush)
                        pixelbrush2.paint(); //apply the paint of the second brush to the canvas (and update the brush)
                        pixelcanvas.transfer(); //transfer the canvas to the FastLED

                        FastLED.show();
                }
                break; //quit the while loop immediately (and delete the created brush)
        }
}

//------------------------------
//HUE FADER: demo of hue fading
//------------------------------
// Animation
void hueDemo()
{
        Serial.println(F(""hue demo""));
        //hue fading can be done in two ways: change the color moving the shortest distance around the colorwheel (setFadeHueNear)
        //or intentionally moving around the colorwheel choosing the long way (setFadeHueFar)
        //two brushes move along the strip in different speeds, each painting a different color that the canvas will then fade to
        //a new color is set when the first brush passes pixel 0
        //both brushes act on the same canvas

        while(true) //create a loop with an additional brush (is deleted automatically once the loop finishes)
        {

                //create an additional brush, painting on the same canvas as the globally defined brush
                FastLEDPainterBrush pixelbrush2 = FastLEDPainterBrush(&pixelcanvas);

                if (pixelbrush2.isvalid() == false) Serial.println(F(""brush2 allocation problem""));
                else Serial.println(F(""brush2 allocation ok""));

                pixelcanvas.clear(); //clear the canvas

                for(loopcounter = 0; loopcounter<duration; loopcounter++)
                {

                        static unsigned int lastposition = 0; //to detect zero crossing only once (brush may stay at pixel zero for some time since it uses sub-pixel resolution movement)

                        if (pixelbrush.getPosition() == 0 && lastposition > 0) initialized = false; //choose new color & speed if brush reaches pixel 0

                        lastposition = pixelbrush.getPosition(); //save current position for next position check

                        if (initialized == false)
                        {
                                initialized = true;

                                //CHSV brushcolor;


                                brushcolor.h = random(255); //random color
                                brushcolor.s = 255; //full saturation
                                brushcolor.v = 130; //medium brightness

                                pixelbrush.setSpeed(random(150) + 150); //random movement speed
                                pixelbrush.setFadeSpeed(random(10) + 20); //set random fading speed
                                pixelbrush.setColor(brushcolor); //update the color of the brush
                                pixelbrush.setFadeHueNear(true); //fade using the near path on the colorcircle

                                //second brush paints on the same canvas
                                brushcolor.h = random(255);
                                pixelbrush2.setSpeed(random(150) + 150);
                                pixelbrush2.setFadeSpeed(random(10) + 20);
                                pixelbrush2.setColor(brushcolor);
                                pixelbrush2.setFadeHueNear(true); //fade using the near path on the colorcircle
                                //pixelbrush.setFadeHueFar(true); //fade using the far path on the colorcircle (if both are set, this path is chosen)
                                pixelbrush2.setBounce(true); //bounce this brush at the end of the strip
                        }

                        FastLED.clear();

                        pixelbrush.paint(); //apply the paint of the first brush to the canvas (and update the brush)
                        pixelbrush2.paint(); //apply the paint of the second brush to the canvas (and update the brush)
                        pixelcanvas.transfer(); //transfer the canvas to the FastLED

                        FastLED.show();
                }
                break; //quit the while loop immediately (and delete the created brush)
        }
}

//------------------------------
//SPEEDTRAILS
//------------------------------
//three brushes painting on one canvas, all following each other at the same speed, painting fading pixels
// Animation
void speedTrails()
{
        Serial.println(F(""speed trails""));
        while(true) //create a loop with two additional brushes (are deleted automatically once the loop finishes)
        {
                int brushspeed = 300; //moving speed was 900 but too fast for teensy

                //create additional brushes, painting on the same canvas as the globally defined brush
                FastLEDPainterBrush pixelbrush2 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to
                FastLEDPainterBrush pixelbrush3 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to

                if (pixelbrush2.isvalid() == false) Serial.println(F(""brush2 allocation problem""));
                else Serial.println(F(""brush2 allocation ok""));

                if (pixelbrush3.isvalid() == false) Serial.println(F(""brush3 allocation problem""));
                else Serial.println(F(""brush3 allocation ok""));

                for(loopcounter = 0; loopcounter<duration; loopcounter++)
                {

                        //CHSV brushcolor;


                        if (initialized == false) //initialize the brushes
                        {
                                initialized = true;
                                brushcolor.h = 0;
                                brushcolor.s = 0; //make it white
                                brushcolor.v = 150; //medium brightness
                                pixelbrush.setColor(brushcolor);
                                pixelbrush.setSpeed(brushspeed);
                                pixelbrush.setFadeSpeed(250); //fast fading (255 is max.)
                                pixelbrush.setFadeHueNear(false); //deactivate hue fading, was activated in last animation
                                pixelbrush.setFadeout(true);
                                pixelbrush.moveTo(0); //move brush to zero

                                //second brush
                                brushcolor.h = 0; //red
                                brushcolor.s = 250;
                                brushcolor.v = 150;
                                pixelbrush2.setSpeed(brushspeed);
                                pixelbrush2.setFadeSpeed(220);
                                pixelbrush2.setFadeout(true);
                                pixelbrush2.setColor(brushcolor);
                                pixelbrush2.moveTo(NUM_LEDS / 3); //move it up one third of the strip

                                //third brush
                                brushcolor.h = 28; //yellow
                                brushcolor.s = 255;
                                brushcolor.v = 100;
                                pixelbrush3.setSpeed(brushspeed);
                                pixelbrush3.setFadeSpeed(190);
                                pixelbrush3.setFadeout(true);
                                pixelbrush3.setColor(brushcolor);
                                pixelbrush3.moveTo(2 * NUM_LEDS / 3); //move it up two thirds of the strip
                        }

                        FastLED.clear();

                        pixelbrush.paint(); //apply the paint of the first brush to the canvas (and update the brush)
                        pixelbrush2.paint(); //apply the paint of the second brush to the canvas (and update the brush)
                        pixelbrush3.paint(); //apply the paint of the third brush to the canvas (and update the brush)
                        pixelcanvas.transfer(); //transfer the canvas to the FastLED (and update i.e. fade pixels)

                        FastLED.show();
                }
                break; //quit the while loop immediately (and delete the created brush)
        }
}

//-------------
//BOUNCY BALLS
//-------------
//three brushes painting on one canvas, attracted to the zero pixel as if by gravity
// Animation
void bouncyBalls()
{
        Serial.println(F(""bouncy balls""));
        while(true) //create a loop with two additional brushes (are deleted automatically once the loop finishes)
        {

                //create additional brushes, painting on the same canvas as the globally defined brush
                FastLEDPainterBrush pixelbrush2 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to
                FastLEDPainterBrush pixelbrush3 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to

                if (pixelbrush2.isvalid() == false) Serial.println(F(""brush2 allocation problem""));
                else Serial.println(F(""brush2 allocation ok""));

                if (pixelbrush3.isvalid() == false) Serial.println(F(""brush3 allocation problem""));
                else Serial.println(F(""brush3 allocation ok""));

                byte skipper = 0;

                for(loopcounter = 0; loopcounter<duration; loopcounter++)
                {


                        if (initialized == false) //initialize the brushes
                        {
                                initialized = true;

                                //CHSV brushcolor;

                                brushcolor.h = 20; //orange
                                brushcolor.s = 240; //almost full saturation
                                brushcolor.v = 150; //medium brightness

                                //first brush
                                pixelbrush.setSpeed(0); //zero initial speed
                                pixelbrush.setFadeSpeed(150);
                                pixelbrush.setFadeout(true);
                                pixelbrush.setColor(brushcolor);
                                pixelbrush.moveTo(NUM_LEDS - 1); //move to end of the strip
                                pixelbrush.setBounce(true); //bounce if either end of the strip is reached

                                //second brush
                                brushcolor.h = 220; //pink
                                pixelbrush2.setSpeed(0); //zero initial speed
                                pixelbrush2.setFadeSpeed(190);
                                pixelbrush2.setFadeout(true);
                                pixelbrush2.setColor(brushcolor);
                                pixelbrush2.moveTo(NUM_LEDS / 3); //move to one third of the strip
                                pixelbrush2.setBounce(true);

                                brushcolor.h = 70; //green-ish (pure green is 85 or 255/3)
                                pixelbrush3.setSpeed(0);
                                pixelbrush3.setFadeSpeed(220);
                                pixelbrush3.setFadeout(true);
                                pixelbrush3.setColor(brushcolor);
                                pixelbrush3.moveTo(2 * NUM_LEDS / 3);
                                pixelbrush3.setBounce(true);
                        }

                        //apply some gravity force that accelerates the painters (i.e. add speed in negative direction = towards zero pixel)
                        //  if (skipper % 5 == 0) //only apply gravity at some interval to make it slower on fast processors
                        //  {
                        //read current speed of each brush and speed it up in negative direction (towards pixel zero)
                        pixelbrush.setSpeed(pixelbrush.getSpeed() - 5);
                        pixelbrush2.setSpeed(pixelbrush2.getSpeed() - 5);
                        pixelbrush3.setSpeed(pixelbrush3.getSpeed() - 5);
                        //  }
                        //  skipper++;


                        FastLED.clear();

                        pixelbrush.paint(); //apply the paint of the first brush to the canvas (and update the brush)
                        pixelbrush2.paint(); //apply the paint of the second brush to the canvas (and update the brush)
                        pixelbrush3.paint(); //apply the paint of the third brush to the canvas (and update the brush)
                        pixelcanvas.transfer(); //transfer the canvas to the FastLED (and update i.e. fade pixels)

                        FastLED.show();
                }
                break; //quit the while loop immediately (and delete the created brush)
        }
}

void bouncyBallsWithInput()
{
        Serial.println(F(""bouncy balls""));
        // while(true) //create a loop with two additional brushes (are deleted automatically once the loop finishes)
        // for(loopcounter = 0; loopcounter<duration; loopcounter++)
        // {

                // readPropShield(); // still want the averages to update

                // //create additional brushes, painting on the same canvas as the globally defined brush
                // FastLEDPainterBrush pixelbrush2 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to
                // FastLEDPainterBrush pixelbrush3 = FastLEDPainterBrush(&pixelcanvas); //crete brush, linked to the canvas to paint to

                // if (pixelbrush2.isvalid() == false) Serial.println(F(""brush2 allocation problem""));
                // else Serial.println(F(""brush2 allocation ok""));

                // if (pixelbrush3.isvalid() == false) Serial.println(F(""brush3 allocation problem""));
                // else Serial.println(F(""brush3 allocation ok""));

                byte skipper = 0;

                for(loopcounter = 0; loopcounter<duration; loopcounter++)
                {

                        readPropShield(); // still want the averages to update
                        
                        if (initialized == false) //initialize the brushes
                        {
                                initialized = true;

                                //CHSV brushcolor;

                                brushcolor.h = 20; //orange
                                brushcolor.s = 240; //almost full saturation
                                // brushcolor.v = 150; //medium brightness
                                brushcolor.v = 110;

                                //first brush
                                pixelbrush.setSpeed(0); //zero initial speed
                                pixelbrush.setFadeSpeed(150);
                                pixelbrush.setFadeout(true);
                                pixelbrush.setColor(brushcolor);
                                pixelbrush.moveTo(NUM_LEDS - 1); //move to end of the strip
                                pixelbrush.setBounce(true); //bounce if either end of the strip is reached

                                //second brush
                                brushcolor.h = 220; //pink
                                pixelbrushBB2.setSpeed(0); //zero initial speed
                                pixelbrushBB2.setFadeSpeed(190);
                                pixelbrushBB2.setFadeout(true);
                                pixelbrushBB2.setColor(brushcolor);
                                pixelbrushBB2.moveTo(NUM_LEDS / 3); //move to one third of the strip
                                pixelbrushBB2.setBounce(true);

                                brushcolor.h = 70; //green-ish (pure green is 85 or 255/3)
                                pixelbrushBB3.setSpeed(0);
                                pixelbrushBB3.setFadeSpeed(220);
                                pixelbrushBB3.setFadeout(true);
                                pixelbrushBB3.setColor(brushcolor);
                                pixelbrushBB3.moveTo(2 * NUM_LEDS / 3);
                                pixelbrushBB3.setBounce(true);
                        }

                        //apply some gravity force that accelerates the painters (i.e. add speed in negative direction = towards zero pixel)
                         if (skipper % 5 == 0) //only apply gravity at some interval to make it slower on fast processors
                         {
                        //read current speed of each brush and speed it up in negative direction (towards pixel zero)
                        pixelbrush.setSpeed(pixelbrush.getSpeed() - 5);
                        pixelbrushBB2.setSpeed(pixelbrushBB2.getSpeed() - 5);
                        pixelbrushBB3.setSpeed(pixelbrushBB3.getSpeed() - 5);
                         }
                         skipper++;


                        FastLED.clear();

                        pixelbrush.paint(); //apply the paint of the first brush to the canvas (and update the brush)
                        pixelbrushBB2.paint(); //apply the paint of the second brush to the canvas (and update the brush)
                        pixelbrushBB3.paint(); //apply the paint of the third brush to the canvas (and update the brush)
                        pixelcanvas.transfer(); //transfer the canvas to the FastLED (and update i.e. fade pixels)

                        FastLED.show();
                }
                // break; //quit the while loop immediately (and delete the created brush)
        // }
        FastLED.clear();
        spinning_animation = false;
}

//---------------------
//TWO-BRUSH-COLORMIXING
//---------------------
//two brushes moving around randomly paint on their individual canvas, resulting in colors being mixed
// Animation
void twoBrushColorMixing()
{
        Serial.println(F(""two brush mix""));
        while(true) //create a loop with two additional brushes (are deleted automatically once the loop finishes)
        {

                //create an additional canvas for the second brush (needs to be created before the brush)
                FastLEDPainterCanvas pixelcanvas2 = FastLEDPainterCanvas(NUM_LEDS);

                //create additional brush, painting on the second canvas
                FastLEDPainterBrush pixelbrush2 = FastLEDPainterBrush(&pixelcanvas2);

                if (pixelcanvas2.isvalid() == false) Serial.println(""canvas2 allocation problem"");
                else Serial.println(""canvas2 allocation ok"");

                if (pixelbrush2.isvalid() == false) Serial.println(F(""brush2 allocation problem""));
                else Serial.println(F(""brush2 allocation ok""));


                for(loopcounter = 0; loopcounter<duration; loopcounter++)
                {


                        //CHSV brushcolor;
                        static bool firstrun = true;

                        brushcolor.s = 255; //full color saturation
                        brushcolor.v = 100; //medium-low brightness

                        if (initialized == false) //initialize the brushes
                        {
                                initialized = true;

                                brushcolor.h = 8;

                                //setup the first brush
                                pixelbrush.setSpeed(-350); //was 750
                                pixelbrush.setSpeedlimit(400);
                                pixelbrush.setFadeSpeed(random(80) + 50);
                                pixelbrush.setFadeout(true);
                                pixelbrush.setFadein(true);
                                pixelbrush.setColor(brushcolor);
                                pixelbrush.moveTo(random(NUM_LEDS));
                                pixelbrush.setBounce(true);

                                //setup the second brush
                                brushcolor.h = 160;
                                pixelbrush2.setSpeed(200); //was 600
                                pixelbrush2.setSpeedlimit(400);
                                pixelbrush2.setFadeSpeed(random(80) + 50);
                                pixelbrush2.setFadeout(true);
                                pixelbrush2.setFadein(true);
                                pixelbrush2.setColor(brushcolor);
                                pixelbrush2.moveTo(random(NUM_LEDS));
                                pixelbrush2.setBounce(true);
                        }


                        if (rand() % 10) //slowly (and randomly) change hue of brushes
                        {
                                brushcolor = pixelbrush.getColor();
                                brushcolor.h += random(3) - 1; //randomly change hue a little ( ± random(1))
                                pixelbrush.setColor(brushcolor);

                                brushcolor = pixelbrush2.getColor();
                                brushcolor.h += random(3) - 1; //randomly change hue a little ( ± random(1))
                                pixelbrush2.setColor(brushcolor);

                        }

                        //slowly change speed of both brushes
                        pixelbrush.setSpeed(pixelbrush.getSpeed() + random(6) - 3); //means speed = currentspeed ± random(3)
                        pixelbrush2.setSpeed(pixelbrush2.getSpeed() + random(6) - 3); //means speed = currentspeed ± random(3)


                        FastLED.clear(); //remove any previously applied paint

                        pixelbrush.paint(); //apply the paint of the first brush to its assigned canvas (and update the brush)
                        pixelbrush2.paint(); //apply the paint of the second brush to  its assigned canvas (and update the brush)

                        pixelcanvas.transfer(); //transfer the first canvas to the FastLED
                        pixelcanvas2.transfer(); //transfer the sedonc canvas to the FastLED (adding colors, rather than overwriting colors)

                        FastLED.show();
                }
                break; //quit the while loop immediately (and delete the created brush)
        }
}


void initI2C() {
        // join I2C bus (I2Cdev library doesn't do this automatically)
    #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
        Wire.begin();
        Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
    #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
        Fastwire::setup(400, true);
    #endif

        // initialize serial communication
        // (115200 chosen because it is required for Teapot Demo output, but it's
        // really up to you depending on your project)
        Serial.begin(115200);
        rainbowBlink();
        //while (!Serial); // wait for Leonardo enumeration, others continue immediately

        // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio
        // Pro Mini running at 3.3v, cannot handle this baud rate reliably due to
        // the baud timing being too misaligned with processor ticks. You must use
        // 38400 or slower in these cases, or use some kind of external separate
        // crystal solution for the UART timer.

        // initialize device
        Serial.println(F(""Initializing I2C devices...""));
        mpu.initialize();
        pinMode(INTERRUPT_PIN, INPUT);

        // verify connection
        Serial.println(F(""Testing device connections...""));
        Serial.println(mpu.testConnection() ? F(""MPU6050 connection successful"") : F(""MPU6050 connection failed""));

        // wait for ready
        Serial.println(F(""\\nSend any character to begin DMP programming and demo: ""));
        // while (Serial.available() && Serial.read()); // empty buffer
        //while (!Serial.available());                 // wait for data
        // while (Serial.available() && Serial.read()); // empty buffer again

        // load and configure the DMP
        Serial.println(F(""Initializing DMP...""));
        devStatus = mpu.dmpInitialize();

        // supply your own gyro offsets here, scaled for min sensitivity
        mpu.setXGyroOffset(220);
        mpu.setYGyroOffset(76);
        mpu.setZGyroOffset(-85);
        mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

        // make sure it worked (returns 0 if so)
        if (devStatus == 0) {
                // turn on the DMP, now that it's ready
                Serial.println(F(""Enabling DMP...""));
                mpu.setDMPEnabled(true);

                // enable Arduino interrupt detection
                Serial.println(F(""Enabling interrupt detection (Arduino external interrupt 0)...""));
                attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING);
                mpuIntStatus = mpu.getIntStatus();

                // set our DMP Ready flag so the main loop() function knows it's okay to use it
                Serial.println(F(""DMP ready! Waiting for first interrupt...""));
                dmpReady = true;

                // get expected DMP packet size for later comparison
                packetSize = mpu.dmpGetFIFOPacketSize();
        } else {
                // ERROR!
                // 1 = initial memory load failed
                // 2 = DMP configuration updates failed
                // (if it's going to break, usually the code will be 1)
                Serial.print(F(""DMP Initialization failed (code ""));
                Serial.print(devStatus);
                Serial.println(F("")""));
        }

        // configure LED for output
        pinMode(LED_PIN, OUTPUT);
}

void initI2C_custom()
{
        Serial.print(F(""here""));
        // if programming failed, don't try to do anything
        if (!dmpReady) return;
        Serial.print(F(""heredddddd""));
        // wait for MPU interrupt or extra packet(s) available
        // while (!mpuInterrupt && fifoCount < packetSize) {
        // other program behavior stuff here
        // .
        // .
        // .
        // if you are really paranoid you can frequently test in between other
        // stuff to see if mpuInterrupt is true, and if so, ""break;"" from the
        // while() loop to immediately process the MPU data
        // .
        // .
        // .
        //   }

        // reset interrupt flag and get INT_STATUS byte
        mpuInterrupt = false;
        mpuIntStatus = mpu.getIntStatus();

        // get current FIFO count
        fifoCount = mpu.getFIFOCount();

        Serial.print(F(""here2""));
        // check for overflow (this should never happen unless our code is too inefficient)
        if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
                // reset so we can continue cleanly
                mpu.resetFIFO();
                Serial.println(F(""FIFO overflow!""));

                // otherwise, check for DMP data ready interrupt (this should happen frequently)

        }


        Serial.print(F(""here3""));
}

void setupPropShield() {
  Serial.begin(9600);
  imu.begin();
  filter.begin(100);
}

void readPropShield() {
  float ax, ay, az;
  float gx, gy, gz;
  float mx, my, mz;
  float roll, pitch, yaw;

  if (imu.available()) {
    // Read the motion sensors
    imu.readMotionSensor(ax, ay, az, gx, gy, gz, mx, my, mz);

    // Update the SensorFusion filter
    filter.update(gx, gy, gz, ax, ay, az, mx, my, mz);

    // print the heading, pitch and roll
    roll = filter.getRoll();
    pitch = filter.getPitch();
    yaw = filter.getYaw();
    ypr[0] = yaw;
    ypr[1] = roll; // pitch and roll seemed to be swapped between ic's
    ypr[2]= pitch;

    // handle the roll rate calc
//     rollHistory.push(pitch);
        // if (millis() - time >= 250 && rollHistory.isFull()) {
        if (millis() - time >= 250) {
                time = millis();
                // float avg = 0.0;
                // float sum = 0;
                // // the following ensures using the right type for the index variable
                // using index_t = decltype(rollHistory)::index_t;
                // for (index_t i = 0; i < rollHistory.size(); i++) {
                //         // avg += buffer[i] / (float)buffer.size();
                //         // roll_rate += rollHistory[i] / (float)rollHistory.size();
                //         sum += rollHistory[i];
                // }

                printInfo2(brushcolor.v);

                // roll_rate = sum / rollHistory.size();
                // Serial.print(""Average is "");
                roll_rate = pitch;
                Serial.print(""RATE is "");
                Serial.print(abs(old_roll_rate - roll_rate));
                Serial.print("" spinning: "");
                Serial.println(spinning_animation);

                if (!spinning_animation && abs(old_roll_rate - roll_rate) > ROLL_THRESHOLD) {
                        // should switch to standard animations
                        spinning_animation = true;
                        // rainbowPaintWithInput();
                        bouncyBallsWithInput();
                }
                old_roll_rate = roll_rate;
        }

//     Serial.print(""Orientation [ypr]: "");
//     Serial.print(yaw);
//     Serial.print("" "");
//     Serial.print(pitch);
//     Serial.print("" "");
//     Serial.println(roll);
  }
}

void readMpu() {
        
        // get current FIFO count
        fifoCount = mpu.getFIFOCount();

        // wait for correct available data length, should be a VERY short wait
        //Serial.print(F(""in readMpu if first""));
        while (fifoCount < packetSize && mpuIntStatus < 1) fifoCount = mpu.getFIFOCount();
        //Serial.print(F(""after readMpu() while ""));

        // read a packet from FIFO
        mpu.getFIFOBytes(fifoBuffer, packetSize);

        // track FIFO count here in case there is > 1 packet available
        // (this lets us immediately read more without waiting for an interrupt)
        fifoCount -= packetSize;

        //HERE IS WHERE THE READS ACTUALLY HAPPEN
  #ifdef OUTPUT_READABLE_YAWPITCHROLL
        // display YAW PITCH AND ROLL angles in degrees
        mpu.dmpGetQuaternion(&qc, fifoBuffer);
        mpu.dmpGetGravity(&gravity, &qc);
        mpu.dmpGetYawPitchRoll(ypr, &qc, &gravity);
        float yaw = ypr[0] * 180/M_PI;
        float pitch = ypr[1] * 180/M_PI;
        float roll = ypr[2] * 180/M_PI;

        if(DEBUG_OUTPUT) {
                Serial.print(""\\typr\\t"");
                Serial.print(yaw);
                Serial.print(""\\t"");
                Serial.print(pitch);
                Serial.print(""\\t"");
                Serial.println(roll);
        }
  #endif

        // blink LED to indicate activity
        blinkState = !blinkState;
        digitalWrite(LED_PIN, blinkState);

}

float readRollOld()
{
        Serial.print(F(""in readRoll()""));
        Serial.print(mpuIntStatus);
        mpuIntStatus = 1;
        if(0x02) Serial.print(F(""0x02""));
        if (mpuIntStatus & 0x02 || true) {
                // wait for correct available data length, should be a VERY short wait
                Serial.print(F(""in readRoll if first""));
                while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();
                Serial.print(F(""after readRoll() while""));

                // read a packet from FIFO
                mpu.getFIFOBytes(fifoBuffer, packetSize);

                // track FIFO count here in case there is > 1 packet available
                // (this lets us immediately read more without waiting for an interrupt)
                fifoCount -= packetSize;

                //HERE IS WHERE THE READS ACTUALLY HAPPEN
        #ifdef OUTPUT_READABLE_YAWPITCHROLL
                // display YAW PITCH AND ROLL angles in degrees
                mpu.dmpGetQuaternion(&qc, fifoBuffer);
                mpu.dmpGetGravity(&gravity, &qc);
                mpu.dmpGetYawPitchRoll(ypr, &qc, &gravity);
                Serial.print(""ypr\\t"");
                float yaw = ypr[0] * 180/M_PI;
                Serial.print(yaw);
                Serial.print(""\\t"");
                float pitch = ypr[1] * 180/M_PI;
                Serial.print(pitch);
                Serial.print(""\\t"");
                float roll = ypr[2] * 180/M_PI;
                Serial.println(roll);
        #endif

                // blink LED to indicate activity
                blinkState = !blinkState;
                digitalWrite(LED_PIN, blinkState);

                return roll;
        }
}

void drip()
{
        boolean backward = true;
        //static signed int speed = 0;
        //for(loopcounter = 0; loopcounter < duration; loopcounter++)
        while(true)
        {
                static unsigned int hue = 0; //color hue to set to brush

                //CHSV brushcolor; //HSV color definition


                if (initialized == false) //initialize the brushes
                {
                        initialized = true;
                        pixelbrush.setFadeSpeed(90);
                        pixelbrush.setFadein(false); //brightness will fade-in if set to true
                        pixelbrush.setFadeout(true);
                        pixelbrush.setBounce(false);
                }

                if(backward)
                {
                        speed -= 1;
                        brushcolor.h = 200;
                }
                else
                {
                        speed += 1;
                        brushcolor.h = 100;
                }

                if(speed > 300)
                {
                        backward = true;
                }
                else if(speed < -300)
                        backward = false;

                Serial.print(""speed"");
                Serial.print(speed);
                Serial.print(""\\n"");

                pixelbrush.setSpeed(speed); //brush moving speed

                //hue++;
                //brushcolor.h = hue; //divide by 3 to slow down color fading
                brushcolor.s = 255; //full saturation
                brushcolor.v = 255; //full brightness

                pixelbrush.setColor(brushcolor); //set new color to the bursh

                FastLED.clear();

                pixelbrush.paint(); //paint the brush to the canvas (and update the brush, i.e. move it a little)
                pixelcanvas.transfer(); //transfer (add) the canvas to the FastLED

                FastLED.show();
        }
}
",16315,True,3449.2135674242145,median
"/*

  Weather.ino
  
  Demonstrates:
    - Weather icons from open-iconic set.
    - Text scrolling.
    - Partial screen update
    
  This example requires display height >= 64.

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_PE12864_004_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_PE12864_004_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list




#define SUN	0
#define SUN_CLOUD  1
#define CLOUD 2
#define RAIN 3
#define THUNDER 4

void drawWeatherSymbol(u8g2_uint_t x, u8g2_uint_t y, uint8_t symbol)
{
  // fonts used:
  // u8g2_font_open_iconic_embedded_6x_t
  // u8g2_font_open_iconic_weather_6x_t
  // encoding values, see: https://github.com/olikraus/u8g2/wiki/fntgrpiconic
  
  switch(symbol)
  {
    case SUN:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 69);	
      break;
    case SUN_CLOUD:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 65);	
      break;
    case CLOUD:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 64);	
      break;
    case RAIN:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 67);	
      break;
    case THUNDER:
      u8g2.setFont(u8g2_font_open_iconic_embedded_6x_t);
      u8g2.drawGlyph(x, y, 67);
      break;      
  }
}

void drawWeather(uint8_t symbol, int degree)
{
  drawWeatherSymbol(0, 48, symbol);
  u8g2.setFont(u8g2_font_logisoso32_tf);
  u8g2.setCursor(48+3, 42);
  u8g2.print(degree);
  u8g2.print(""°C"");		// requires enableUTF8Print()
}

/*
  Draw a string with specified pixel offset. 
  The offset can be negative.
  Limitation: The monochrome font with 8 pixel per glyph
*/
void drawScrollString(int16_t offset, const char *s)
{
  static char buf[36];	// should for screen with up to 256 pixel width 
  size_t len;
  size_t char_offset = 0;
  u8g2_uint_t dx = 0;
  size_t visible = 0;
  

  u8g2.setDrawColor(0);		// clear the scrolling area
  u8g2.drawBox(0, 49, u8g2.getDisplayWidth()-1, u8g2.getDisplayHeight()-1);
  u8g2.setDrawColor(1);		// set the color for the text
    
  
  len = strlen(s);
  if ( offset < 0 )
  {
    char_offset = (-offset)/8;
    dx = offset + char_offset*8;
    if ( char_offset >= u8g2.getDisplayWidth()/8 )
      return;
    visible = u8g2.getDisplayWidth()/8-char_offset+1;
    strncpy(buf, s, visible);
    buf[visible] = '\\0';
    u8g2.setFont(u8g2_font_8x13_mf);
    u8g2.drawStr(char_offset*8-dx, 62, buf);
  }
  else
  {
    char_offset = offset / 8;
    if ( char_offset >= len )
      return;	// nothing visible
    dx = offset - char_offset*8;
    visible = len - char_offset;
    if ( visible > u8g2.getDisplayWidth()/8+1 )
      visible = u8g2.getDisplayWidth()/8+1;
    strncpy(buf, s+char_offset, visible);
    buf[visible] = '\\0';
    u8g2.setFont(u8g2_font_8x13_mf);
    u8g2.drawStr(-dx, 62, buf);
  }
  
}

void draw(const char *s, uint8_t symbol, int degree)
{
  int16_t offset = -(int16_t)u8g2.getDisplayWidth();
  int16_t len = strlen(s);
  
  u8g2.clearBuffer();					// clear the internal memory
  drawWeather(symbol, degree);		// draw the icon and degree only once
  for(;;)							// then do the scrolling
  {
  
    drawScrollString(offset, s);  			// no clearBuffer required, screen will be partially cleared here
    u8g2.sendBuffer();				// transfer internal memory to the display

    delay(20);
    offset+=2;
    if ( offset > len*8+1 )
      break;
  }
}


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  
  digitalWrite(10, 0);
  digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
  u8g2.enableUTF8Print();
}

void loop(void) {

  draw(""What a beautiful day!"", SUN, 27);
  draw(""The sun's come out!"", SUN_CLOUD, 19);
  draw(""It's raining cats and dogs."", RAIN, 8);
  draw(""That sounds like thunder."", THUNDER, 12);
  draw(""It's stopped raining"", CLOUD, 15);
  
  
  
}

",16235,True,4577.321355122744,median
"package
{
import com.adobe.serialization.json.JSONDecoder;

import flash.display.Sprite;

import ruby.internals.RbISeq;
import ruby.internals.RubyCore;
import ruby.internals.RubyFrame;

public class RubyVMMain extends Sprite
{
  public function RubyVMMain()
  {
    super();
    var rc:RubyCore = new RubyCore();
    // Must do ruby_init to prep for creating iseq.
    rc.run(get_bytecode(), this);
  }

  protected function get_bytecode():String
  {
    var s:String =
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":5},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""v\\""],0,[],[1,[\\""trace\\"",1],[\\""putstring\\"",\\""hi\\""],[\\""setlocal\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""pt\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":3,\\""local_size\\"":4,\\""stack_max\\"":2},\\""pt\\"",\\""<compiled>\\"",\\""method\\"",[\\""a\\"",\\""b\\"",\\""c\\""],3,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""getlocal\\"",4],[\\""getlocal\\"",3],[\\""opt_plus\\""],[\\""getlocal\\"",2],[\\""opt_plus\\""],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],5,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""mimic\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":1,\\""local_size\\"":2,\\""stack_max\\"":1},\\""mimic\\"",\\""<compiled>\\"",\\""method\\"",[\\""a\\""],1,[],[7,[\\""trace\\"",8],6,[\\""trace\\"",1],[\\""getlocal\\"",2],7,[\\""trace\\"",16],6,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],8,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""wait\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""wait\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[10,[\\""trace\\"",8],9,[\\""trace\\"",1],[\\""putstring\\"",\\""done waiting\\""],10,[\\""trace\\"",16],9,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],11,[\\""trace\\"",1],[\\""putnil\\""],[\\""putnil\\""],[\\""putstring\\"",\\""wait 5\\""],[\\""send\\"",\\""mimic\\"",1,null,8,null],[\\""send\\"",\\""puts\\"",1,null,8,null],[\\""pop\\""],12,[\\""trace\\"",1],[\\""putnil\\""],[\\""putnil\\""],[\\""send\\"",\\""wait\\"",0,null,8,null],[\\""send\\"",\\""puts\\"",1,null,8,null],[\\""pop\\""],13,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[15,[\\""trace\\"",8],14,[\\""trace\\"",1],[\\""putobject\\"",65280],15,[\\""trace\\"",16],14,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],16,[\\""trace\\"",1],\\""label_112\\"",[\\""getinlinecache\\"",null,\\""label_119\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_112\\""],\\""label_119\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],17,[\\""trace\\"",1],\\""label_140\\"",[\\""getinlinecache\\"",null,\\""label_147\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_140\\""],\\""label_147\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putnil\\""],[\\""send\\"",\\""col\\"",0,null,24,null],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],18,[\\""trace\\"",1],\\""label_169\\"",[\\""getinlinecache\\"",null,\\""label_176\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_169\\""],\\""label_176\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],[\\""leave\\""]]]"";
    //some functions
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":5},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""v\\""],0,[],[1,[\\""trace\\"",1],[\\""putstring\\"",\\""hi\\""],[\\""setlocal\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""pt\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":3,\\""local_size\\"":4,\\""stack_max\\"":2},\\""pt\\"",\\""<compiled>\\"",\\""method\\"",[\\""a\\"",\\""b\\"",\\""c\\""],3,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""getlocal\\"",4],[\\""getlocal\\"",3],[\\""opt_plus\\""],[\\""getlocal\\"",2],[\\""opt_plus\\""],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],5,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""mimic\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":1,\\""local_size\\"":2,\\""stack_max\\"":1},\\""mimic\\"",\\""<compiled>\\"",\\""method\\"",[\\""a\\""],1,[],[7,[\\""trace\\"",8],6,[\\""trace\\"",1],[\\""getlocal\\"",2],7,[\\""trace\\"",16],6,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],8,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""wait\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""wait\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[10,[\\""trace\\"",8],9,[\\""trace\\"",1],[\\""putstring\\"",\\""done waiting\\""],10,[\\""trace\\"",16],9,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],11,[\\""trace\\"",1],[\\""putnil\\""],[\\""putnil\\""],[\\""putstring\\"",\\""wait 5\\""],[\\""send\\"",\\""mimic\\"",1,null,8,null],[\\""send\\"",\\""puts\\"",1,null,8,null],[\\""pop\\""],12,[\\""trace\\"",1],[\\""putnil\\""],[\\""putnil\\""],[\\""send\\"",\\""wait\\"",0,null,8,null],[\\""send\\"",\\""puts\\"",1,null,8,null],[\\""pop\\""],13,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[15,[\\""trace\\"",8],14,[\\""trace\\"",1],[\\""putobject\\"",255],15,[\\""trace\\"",16],14,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],16,[\\""trace\\"",1],\\""label_112\\"",[\\""getinlinecache\\"",null,\\""label_119\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_112\\""],\\""label_119\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],17,[\\""trace\\"",1],\\""label_140\\"",[\\""getinlinecache\\"",null,\\""label_147\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_140\\""],\\""label_147\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putnil\\""],[\\""send\\"",\\""col\\"",0,null,24,null],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],18,[\\""trace\\"",1],\\""label_169\\"",[\\""getinlinecache\\"",null,\\""label_176\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_169\\""],\\""label_176\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],[\\""leave\\""]]]"";

    // create class
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[10,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",3368499],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],[\\""pop\\""],5,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":5},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[9,[\\""trace\\"",8],6,[\\""trace\\"",1],\\""label_4\\"",[\\""getinlinecache\\"",null,\\""label_11\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_4\\""],\\""label_11\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],7,[\\""trace\\"",1],\\""label_32\\"",[\\""getinlinecache\\"",null,\\""label_39\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_32\\""],\\""label_39\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putnil\\""],[\\""send\\"",\\""col\\"",0,null,24,null],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],8,[\\""trace\\"",1],\\""label_61\\"",[\\""getinlinecache\\"",null,\\""label_68\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_61\\""],\\""label_68\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],9,[\\""trace\\"",16],8,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],10,[\\""trace\\"",4],5,[\\""leave\\""]]],0],[\\""pop\\""],11,[\\""trace\\"",1],\\""label_12\\"",[\\""getinlinecache\\"",null,\\""label_19\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_12\\""],\\""label_19\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],12,[\\""trace\\"",1],[\\""getlocal\\"",2],[\\""send\\"",\\""a\\"",0,null,0,null],[\\""leave\\""]]]"";

    // class + module
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""B\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<module:B>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[5,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",6697762],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],5,[\\""trace\\"",4],2,[\\""leave\\""]]],2],[\\""pop\\""],6,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[13,[\\""trace\\"",2],7,[\\""trace\\"",1],[\\""putnil\\""],\\""label_5\\"",[\\""getinlinecache\\"",null,\\""label_12\\""],[\\""getconstant\\"",\\""B\\""],[\\""setinlinecache\\"",\\""label_5\\""],\\""label_12\\"",[\\""send\\"",\\""include\\"",1,null,8,null],[\\""pop\\""],8,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":5},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[12,[\\""trace\\"",8],9,[\\""trace\\"",1],\\""label_4\\"",[\\""getinlinecache\\"",null,\\""label_11\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_4\\""],\\""label_11\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],10,[\\""trace\\"",1],\\""label_32\\"",[\\""getinlinecache\\"",null,\\""label_39\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_32\\""],\\""label_39\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putnil\\""],[\\""send\\"",\\""col\\"",0,null,24,null],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],11,[\\""trace\\"",1],\\""label_61\\"",[\\""getinlinecache\\"",null,\\""label_68\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_61\\""],\\""label_68\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],12,[\\""trace\\"",16],11,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],13,[\\""trace\\"",4],8,[\\""leave\\""]]],0],[\\""pop\\""],14,[\\""trace\\"",1],\\""label_22\\"",[\\""getinlinecache\\"",null,\\""label_29\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_22\\""],\\""label_29\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],15,[\\""trace\\"",1],[\\""getlocal\\"",2],[\\""send\\"",\\""a\\"",0,null,0,null],[\\""leave\\""]]]"";

    // obj.extend module
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""B\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<module:B>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[5,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",6697898],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],5,[\\""trace\\"",4],2,[\\""leave\\""]]],2],[\\""pop\\""],6,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[12,[\\""trace\\"",2],7,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":5},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[11,[\\""trace\\"",8],8,[\\""trace\\"",1],\\""label_4\\"",[\\""getinlinecache\\"",null,\\""label_11\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_4\\""],\\""label_11\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],9,[\\""trace\\"",1],\\""label_32\\"",[\\""getinlinecache\\"",null,\\""label_39\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_32\\""],\\""label_39\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putnil\\""],[\\""send\\"",\\""col\\"",0,null,24,null],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],10,[\\""trace\\"",1],\\""label_61\\"",[\\""getinlinecache\\"",null,\\""label_68\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_61\\""],\\""label_68\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],11,[\\""trace\\"",16],10,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],12,[\\""trace\\"",4],7,[\\""leave\\""]]],0],[\\""pop\\""],13,[\\""trace\\"",1],\\""label_22\\"",[\\""getinlinecache\\"",null,\\""label_29\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_22\\""],\\""label_29\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],14,[\\""trace\\"",1],[\\""getlocal\\"",2],\\""label_41\\"",[\\""getinlinecache\\"",null,\\""label_48\\""],[\\""getconstant\\"",\\""B\\""],[\\""setinlinecache\\"",\\""label_41\\""],\\""label_48\\"",[\\""send\\"",\\""extend\\"",1,null,0,null],[\\""pop\\""],15,[\\""trace\\"",1],[\\""getlocal\\"",2],[\\""send\\"",\\""a\\"",0,null,0,null],[\\""leave\\""]]]"";

    // block and yield
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[[\\""break\\"",null,\\""label_57\\"",\\""label_65\\"",\\""label_65\\"",0]],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""B\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<module:B>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[5,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",6728243],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],5,[\\""trace\\"",4],2,[\\""leave\\""]]],2],[\\""pop\\""],6,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[10,[\\""trace\\"",2],7,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[9,[\\""trace\\"",8],8,[\\""trace\\"",1],[\\""invokeblock\\"",0,0],9,[\\""trace\\"",16],8,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],10,[\\""trace\\"",4],7,[\\""leave\\""]]],0],[\\""pop\\""],11,[\\""trace\\"",1],\\""label_22\\"",[\\""getinlinecache\\"",null,\\""label_29\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_22\\""],\\""label_29\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],12,[\\""trace\\"",1],[\\""getlocal\\"",2],\\""label_41\\"",[\\""getinlinecache\\"",null,\\""label_48\\""],[\\""getconstant\\"",\\""B\\""],[\\""setinlinecache\\"",\\""label_41\\""],\\""label_48\\"",[\\""send\\"",\\""extend\\"",1,null,0,null],[\\""pop\\""],13,[\\""trace\\"",1],\\""label_57\\"",[\\""getlocal\\"",2],[\\""send\\"",\\""a\\"",0,[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":5},\\""block in <compiled>\\"",\\""<compiled>\\"",\\""block\\"",[],0,[[\\""redo\\"",null,\\""label_0\\"",\\""label_81\\"",\\""label_0\\"",0],[\\""next\\"",null,\\""label_0\\"",\\""label_81\\"",\\""label_81\\"",0]],[\\""label_0\\"",14,[\\""trace\\"",1],\\""label_2\\"",[\\""getinlinecache\\"",null,\\""label_9\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_2\\""],\\""label_9\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],15,[\\""trace\\"",1],\\""label_30\\"",[\\""getinlinecache\\"",null,\\""label_37\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_30\\""],\\""label_37\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",3386094],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],16,[\\""trace\\"",1],\\""label_54\\"",[\\""getinlinecache\\"",null,\\""label_61\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_54\\""],\\""label_61\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],\\""label_81\\"",[\\""leave\\""]]],0,null],\\""label_65\\"",[\\""leave\\""]]]"";

    // create new Sprite
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[[\\""break\\"",null,\\""label_57\\"",\\""label_65\\"",\\""label_65\\"",0]],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""B\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<module:B>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[5,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",6728243],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],5,[\\""trace\\"",4],2,[\\""leave\\""]]],2],[\\""pop\\""],6,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[10,[\\""trace\\"",2],7,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[9,[\\""trace\\"",8],8,[\\""trace\\"",1],[\\""invokeblock\\"",0,0],9,[\\""trace\\"",16],8,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],10,[\\""trace\\"",4],7,[\\""leave\\""]]],0],[\\""pop\\""],11,[\\""trace\\"",1],\\""label_22\\"",[\\""getinlinecache\\"",null,\\""label_29\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_22\\""],\\""label_29\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],12,[\\""trace\\"",1],[\\""getlocal\\"",2],\\""label_41\\"",[\\""getinlinecache\\"",null,\\""label_48\\""],[\\""getconstant\\"",\\""B\\""],[\\""setinlinecache\\"",\\""label_41\\""],\\""label_48\\"",[\\""send\\"",\\""extend\\"",1,null,0,null],[\\""pop\\""],13,[\\""trace\\"",1],\\""label_57\\"",[\\""getlocal\\"",2],[\\""send\\"",\\""a\\"",0,[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":5},\\""block in <compiled>\\"",\\""<compiled>\\"",\\""block\\"",[\\""s\\""],0,[[\\""redo\\"",null,\\""label_0\\"",\\""label_110\\"",\\""label_0\\"",0],[\\""next\\"",null,\\""label_0\\"",\\""label_110\\"",\\""label_110\\"",0]],[\\""label_0\\"",14,[\\""trace\\"",1],\\""label_2\\"",[\\""getinlinecache\\"",null,\\""label_13\\""],[\\""getconstant\\"",\\""Flash\\""],[\\""getconstant\\"",\\""Display\\""],[\\""getconstant\\"",\\""Sprite\\""],[\\""setinlinecache\\"",\\""label_2\\""],\\""label_13\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setdynamic\\"",2,0],15,[\\""trace\\"",1],\\""label_24\\"",[\\""getinlinecache\\"",null,\\""label_31\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_24\\""],\\""label_31\\"",[\\""getdynamic\\"",2,0],[\\""send\\"",\\""addChild\\"",1,null,0,null],[\\""pop\\""],16,[\\""trace\\"",1],[\\""getdynamic\\"",2,0],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],17,[\\""trace\\"",1],[\\""getdynamic\\"",2,0],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",3386094],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],18,[\\""trace\\"",1],[\\""getdynamic\\"",2,0],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],\\""label_110\\"",[\\""leave\\""]]],0,null],\\""label_65\\"",[\\""leave\\""]]]"";

    // access variable from closure scope
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":3,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\"",\\""s\\""],0,[[\\""break\\"",null,\\""label_78\\"",\\""label_86\\"",\\""label_86\\"",0]],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""B\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<module:B>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[5,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",6728243],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],5,[\\""trace\\"",4],2,[\\""leave\\""]]],2],[\\""pop\\""],6,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[10,[\\""trace\\"",2],7,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[9,[\\""trace\\"",8],8,[\\""trace\\"",1],[\\""invokeblock\\"",0,0],9,[\\""trace\\"",16],8,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],10,[\\""trace\\"",4],7,[\\""leave\\""]]],0],[\\""pop\\""],11,[\\""trace\\"",1],\\""label_22\\"",[\\""getinlinecache\\"",null,\\""label_29\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_22\\""],\\""label_29\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",3],12,[\\""trace\\"",1],[\\""getlocal\\"",3],\\""label_41\\"",[\\""getinlinecache\\"",null,\\""label_48\\""],[\\""getconstant\\"",\\""B\\""],[\\""setinlinecache\\"",\\""label_41\\""],\\""label_48\\"",[\\""send\\"",\\""extend\\"",1,null,0,null],[\\""pop\\""],13,[\\""trace\\"",1],\\""label_57\\"",[\\""getinlinecache\\"",null,\\""label_68\\""],[\\""getconstant\\"",\\""Flash\\""],[\\""getconstant\\"",\\""Display\\""],[\\""getconstant\\"",\\""Sprite\\""],[\\""setinlinecache\\"",\\""label_57\\""],\\""label_68\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],14,[\\""trace\\"",1],\\""label_78\\"",[\\""getlocal\\"",3],[\\""send\\"",\\""a\\"",0,[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":5},\\""block in <compiled>\\"",\\""<compiled>\\"",\\""block\\"",[],0,[[\\""redo\\"",null,\\""label_0\\"",\\""label_88\\"",\\""label_0\\"",0],[\\""next\\"",null,\\""label_0\\"",\\""label_88\\"",\\""label_88\\"",0]],[\\""label_0\\"",15,[\\""trace\\"",1],\\""label_2\\"",[\\""getinlinecache\\"",null,\\""label_9\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_2\\""],\\""label_9\\"",[\\""getdynamic\\"",2,1],[\\""send\\"",\\""addChild\\"",1,null,0,null],[\\""pop\\""],16,[\\""trace\\"",1],[\\""getdynamic\\"",2,1],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],17,[\\""trace\\"",1],[\\""getdynamic\\"",2,1],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",3386094],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],18,[\\""trace\\"",1],[\\""getdynamic\\"",2,1],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],\\""label_88\\"",[\\""leave\\""]]],0,null],\\""label_86\\"",[\\""leave\\""]]]"";

    // yield a value
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":2},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[[\\""break\\"",null,\\""label_57\\"",\\""label_65\\"",\\""label_65\\"",0]],[1,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""B\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<module:B>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[5,[\\""trace\\"",2],2,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""col\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":1},\\""col\\"",\\""<compiled>\\"",\\""method\\"",[],0,[],[4,[\\""trace\\"",8],3,[\\""trace\\"",1],[\\""putobject\\"",6728243],4,[\\""trace\\"",16],3,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],5,[\\""trace\\"",4],2,[\\""leave\\""]]],2],[\\""pop\\""],6,[\\""trace\\"",1],[\\""putspecialobject\\"",2],[\\""putnil\\""],[\\""defineclass\\"",\\""A\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":1,\\""stack_max\\"":4},\\""<class:A>\\"",\\""<compiled>\\"",\\""class\\"",[],0,[],[11,[\\""trace\\"",2],7,[\\""trace\\"",1],[\\""putspecialobject\\"",1],[\\""putspecialobject\\"",2],[\\""putobject\\"",\\""a\\""],[\\""putiseq\\"",[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":1},\\""a\\"",\\""<compiled>\\"",\\""method\\"",[\\""sp\\""],0,[],[10,[\\""trace\\"",8],8,[\\""trace\\"",1],\\""label_4\\"",[\\""getinlinecache\\"",null,\\""label_15\\""],[\\""getconstant\\"",\\""Flash\\""],[\\""getconstant\\"",\\""Display\\""],[\\""getconstant\\"",\\""Sprite\\""],[\\""setinlinecache\\"",\\""label_4\\""],\\""label_15\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],9,[\\""trace\\"",1],[\\""getlocal\\"",2],[\\""invokeblock\\"",1,0],10,[\\""trace\\"",16],9,[\\""leave\\""]]]],[\\""send\\"",\\""core#define_method\\"",3,null,0,null],11,[\\""trace\\"",4],7,[\\""leave\\""]]],0],[\\""pop\\""],12,[\\""trace\\"",1],\\""label_22\\"",[\\""getinlinecache\\"",null,\\""label_29\\""],[\\""getconstant\\"",\\""A\\""],[\\""setinlinecache\\"",\\""label_22\\""],\\""label_29\\"",[\\""send\\"",\\""new\\"",0,null,0,null],[\\""setlocal\\"",2],13,[\\""trace\\"",1],[\\""getlocal\\"",2],\\""label_41\\"",[\\""getinlinecache\\"",null,\\""label_48\\""],[\\""getconstant\\"",\\""B\\""],[\\""setinlinecache\\"",\\""label_41\\""],\\""label_48\\"",[\\""send\\"",\\""extend\\"",1,null,0,null],[\\""pop\\""],14,[\\""trace\\"",1],\\""label_57\\"",[\\""getlocal\\"",2],[\\""send\\"",\\""a\\"",0,[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":1,\\""local_size\\"":2,\\""stack_max\\"":5},\\""block in <compiled>\\"",\\""<compiled>\\"",\\""block\\"",[\\""s\\""],[1,[],0,0,-1,-1,3],[[\\""redo\\"",null,\\""label_0\\"",\\""label_88\\"",\\""label_0\\"",0],[\\""next\\"",null,\\""label_0\\"",\\""label_88\\"",\\""label_88\\"",0]],[\\""label_0\\"",15,[\\""trace\\"",1],\\""label_2\\"",[\\""getinlinecache\\"",null,\\""label_9\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_2\\""],\\""label_9\\"",[\\""getdynamic\\"",2,0],[\\""send\\"",\\""addChild\\"",1,null,0,null],[\\""pop\\""],16,[\\""trace\\"",1],[\\""getdynamic\\"",2,0],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],17,[\\""trace\\"",1],[\\""getdynamic\\"",2,0],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",3386094],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],18,[\\""trace\\"",1],[\\""getdynamic\\"",2,0],[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],\\""label_88\\"",[\\""leave\\""]]],0,null],\\""label_65\\"",[\\""leave\\""]]]"";

    // create an array
    //""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":5},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[],[1,[\\""trace\\"",1],[\\""duparray\\"",[1,1,1]],[\\""setlocal\\"",2],2,[\\""trace\\"",1],\\""label_8\\"",[\\""getinlinecache\\"",null,\\""label_15\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_8\\""],\\""label_15\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""putobject\\"",1],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],3,[\\""trace\\"",1],\\""label_36\\"",[\\""getinlinecache\\"",null,\\""label_43\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_36\\""],\\""label_43\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",3386094],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],4,[\\""trace\\"",1],\\""label_60\\"",[\\""getinlinecache\\"",null,\\""label_67\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_60\\""],\\""label_67\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],[\\""leave\\""]]]"";

    // array aref
    ""[\\""YARVInstructionSequence\\\\/SimpleDataFormat\\"",1,1,1,{\\""arg_size\\"":0,\\""local_size\\"":2,\\""stack_max\\"":5},\\""<compiled>\\"",\\""<compiled>\\"",\\""top\\"",[\\""a\\""],0,[],[1,[\\""trace\\"",1],[\\""duparray\\"",[1,1,1]],[\\""setlocal\\"",2],2,[\\""trace\\"",1],\\""label_8\\"",[\\""getinlinecache\\"",null,\\""label_15\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_8\\""],\\""label_15\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""getlocal\\"",2],[\\""putobject\\"",0],[\\""opt_aref\\""],[\\""getlocal\\"",2],[\\""putobject\\"",1],[\\""opt_aref\\""],[\\""getlocal\\"",2],[\\""putobject\\"",2],[\\""opt_aref\\""],[\\""send\\"",\\""lineStyle\\"",3,null,0,null],[\\""pop\\""],3,[\\""trace\\"",1],\\""label_45\\"",[\\""getinlinecache\\"",null,\\""label_52\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_45\\""],\\""label_52\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",3386094],[\\""send\\"",\\""beginFill\\"",1,null,0,null],[\\""pop\\""],4,[\\""trace\\"",1],\\""label_69\\"",[\\""getinlinecache\\"",null,\\""label_76\\""],[\\""getconstant\\"",\\""Document\\""],[\\""setinlinecache\\"",\\""label_69\\""],\\""label_76\\"",[\\""send\\"",\\""graphics\\"",0,null,0,null],[\\""putobject\\"",5],[\\""putobject\\"",5],[\\""putobject\\"",105],[\\""putobject\\"",105],[\\""send\\"",\\""drawRect\\"",4,null,0,null],[\\""leave\\""]]]"";
    return s;
  }

  protected function get_iseq(rc:RubyCore):Array
  {
    var s:String = get_bytecode();

    var decoder:JSONDecoder = new JSONDecoder( s, rc )
    return decoder.getValue();

    //return JSON.decode(s);
  }

  protected function ruby_iseq2(rc:RubyCore):Array
  {
    return [
  ""YARVInstructionSequence/SimpleDataFormat"", 1, 1, 1,
  {arg_size:0, local_size:2, stack_max:5},
  ""<compiled>"", ""<compiled>"",
  ""top"",
  [""v""],
  0,
  [],
  [
    [""putstring"", ""hi""],
    [""setlocal"", 2],
    [""putspecialobject"", 1],
    [""putspecialobject"", 2],
    [""putobject"", ""mimic""],
    [""putiseq"",
      [
        ""YARVInstructionSequence/SimpleDataFormat"", 1, 1, 1,
        {arg_size:1, local_size:2, stack_max:1},
        ""mimic"", ""<compiled>"",
        ""method"",
        [""a""],
        1,
        [],
        [
          [""getlocal"", 2],
          [""leave""],
        ]
      ]
    ],
    [""send"", ""core#define_method"", 3, rc.Qnil, 0, rc.Qnil],
    [""pop""],
    [""putspecialobject"", 1],
    [""putspecialobject"", 2],
    [""putobject"", ""wait""],
    [""putiseq"",
      [
        ""YARVInstructionSequence/SimpleDataFormat"", 1, 1, 1,
        {arg_size:0, local_size:1, stack_max:1},
        ""wait"", ""<compiled>"",
        ""method"",
        [],
        0,
        [],
        [
          [""putstring"", ""done waiting""],
          [""leave""],
        ]
      ]
    ],
    [""send"", ""core#define_method"", 3, rc.Qnil, 0, rc.Qnil],
    [""pop""],
    [""putnil""],
    [""putnil""],
    [""putstring"", ""wait 5""],
    [""send"", ""mimic"", 1, rc.Qnil, 8, rc.Qnil],
    [""send"", ""puts"", 1, rc.Qnil, 8, rc.Qnil],
    [""pop""],
    [""putnil""],
    [""putnil""],
    [""send"", ""wait"", 0, rc.Qnil, 8, rc.Qnil],
    [""send"", ""puts"", 1, rc.Qnil, 8, rc.Qnil],
    [""pop""],
    [""putspecialobject"", 1],
    [""putspecialobject"", 2],
    [""putobject"", ""col""],
    [""putiseq"",
      [
        ""YARVInstructionSequence/SimpleDataFormat"", 1, 1, 1,
        {arg_size:0, local_size:1, stack_max:1},
        ""col"", ""<compiled>"",
        ""method"",
        [],
        0,
        [],
        [
          [""putobject"", 65280],
          [""leave""],
        ]
      ]
    ],
    [""send"", ""core#define_method"", 3, rc.Qnil, 0, rc.Qnil],
    [""pop""],
    ""label_95"",
    [""getinlinecache"", rc.Qnil, ""label_102""],
    [""getconstant"", ""Document""],
    [""setinlinecache"", ""label_95""],
    ""label_102"",
    [""send"", ""graphics"", 0, rc.Qnil, 0, rc.Qnil],
    [""putobject"", 1],
    [""putobject"", 1],
    [""putobject"", 1],
    [""send"", ""lineStyle"", 3, rc.Qnil, 0, rc.Qnil],
    [""pop""],
    ""label_123"",
    [""getinlinecache"", rc.Qnil, ""label_130""],
    [""getconstant"", ""Document""],
    [""setinlinecache"", ""label_123""],
    ""label_130"",
    [""send"", ""graphics"", 0, rc.Qnil, 0, rc.Qnil],
    [""putnil""],
    [""send"", ""col"", 0, rc.Qnil, 24, rc.Qnil],
    [""send"", ""beginFill"", 1, rc.Qnil, 0, rc.Qnil],
    [""pop""],
    ""label_152"",
    [""getinlinecache"", rc.Qnil, ""label_159""],
    [""getconstant"", ""Document""],
    [""setinlinecache"", ""label_152""],
    ""label_159"",
    [""send"", ""graphics"", 0, rc.Qnil, 0, rc.Qnil],
    [""putobject"", 5],
    [""putobject"", 5],
    [""putobject"", 105],
    [""putobject"", 105],
    [""send"", ""drawRect"", 4, rc.Qnil, 0, rc.Qnil],
    [""leave""],
  ]
];


  }

  protected function ruby_func2():Function
  {
    return function (f:RubyFrame):void {
      f.putnil();
      f.putstring(""THIS IS A STRING FROM RUBY!!"");
      f.send(""puts"", 1, f.Qnil, 8, f.Qnil);

      f.putstring(""put this into local var"");
      f.setlocal(2);

      f.putnil();
      f.getlocal(2);
      f.send(""puts"", 1, f.Qnil, 8, f.Qnil);

      f.putnil();
      f.putstring(""This is another string."");
      f.send(""puts"", 1, f.Qnil, 8, f.Qnil);

      f.putspecialobject(2);
      f.putnil();
      var class_iseq:RbISeq = f.rc.class_iseq_from_func(""A"", 0, 1, 1,
      function(f:RubyFrame):void {

        f.putspecialobject(1);
        f.putspecialobject(2);
        f.putobject(""m"");

        var m_iseq:RbISeq = f.rc.method_iseq_from_func(""m"", 0, 1, 1,
        function(f:RubyFrame):void {
          f.putstring(""RETURNED from A#m"");
          f.leave();
        });

        f.putiseq(m_iseq);
        f.send(""core#define_method"", 3, f.Qnil, 0, f.Qnil);

        f.putnil();
        f.leave();
      });

      f.defineclass(""A"", class_iseq, 0);
      f.pop();

      f.getinlinecache(f.Qnil, ""label_31"");
      f.getconstant(""A"");
      f.setinlinecache(""label_24"");
      f.send(""new"", 0, f.Qnil, 0, f.Qnil);
      f.setlocal(2);

      f.putnil();
      f.getlocal(2);
      f.send(""m"", 0, f.Qnil, 0, f.Qnil);
      f.send(""puts"", 1, f.Qnil, 8, f.Qnil);

      // [:leave]
      f.leave();
    };
  }

}
}
",12210,True,3114.319594305867,median
"package com.company.assembleegameclient.objects {
import com.company.assembleegameclient.map.Camera;
import com.company.assembleegameclient.map.Square;
import com.company.assembleegameclient.map.mapoverlay.CharacterStatusText;
import com.company.assembleegameclient.objects.particles.HealingEffect;
import com.company.assembleegameclient.objects.particles.LevelUpEffect;
import com.company.assembleegameclient.parameters.Parameters;
import com.company.assembleegameclient.parameters.Parameters;
import com.company.assembleegameclient.sound.SoundEffectLibrary;
import com.company.assembleegameclient.tutorial.Tutorial;
import com.company.assembleegameclient.tutorial.doneAction;
import com.company.assembleegameclient.util.AnimatedChar;
import com.company.assembleegameclient.util.ConditionEffect;
import com.company.assembleegameclient.util.FameUtil;
import com.company.assembleegameclient.util.FreeList;
import com.company.assembleegameclient.util.MaskedImage;
import com.company.assembleegameclient.util.TextureRedrawer;
import com.company.assembleegameclient.util.redrawers.GlowRedrawer;
import com.company.util.CachingColorTransformer;
import com.company.util.ConversionUtil;
import com.company.util.GraphicsUtil;
import com.company.util.IntPoint;
import com.company.util.MoreColorUtil;
import com.company.util.PointUtil;
import com.company.util.Trig;

import flash.display.BitmapData;
import flash.display.GraphicsPath;
import flash.display.GraphicsSolidFill;
import flash.display.IGraphicsData;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
import flash.utils.getTimer;

import kabam.rotmg.assets.services.CharacterFactory;
import kabam.rotmg.chat.model.ChatMessage;
import kabam.rotmg.constants.ActivationType;
import kabam.rotmg.constants.GeneralConstants;
import kabam.rotmg.constants.UseType;
import kabam.rotmg.core.StaticInjectorContext;
import kabam.rotmg.game.model.PotionInventoryModel;
import kabam.rotmg.game.signals.AddTextLineSignal;
import kabam.rotmg.game.view.components.QueuedStatusText;
import kabam.rotmg.messaging.impl.data.StatData;
import kabam.rotmg.stage3D.GraphicsFillExtra;
import kabam.rotmg.text.model.NumberKey;
import kabam.rotmg.text.model.TextKey;
import kabam.rotmg.text.view.BitmapTextFactory;
import kabam.rotmg.text.view.stringBuilder.LineBuilder;
import kabam.rotmg.text.view.stringBuilder.StaticStringBuilder;
import kabam.rotmg.text.view.stringBuilder.StringBuilder;
import kabam.rotmg.ui.model.TabStripModel;

import org.swiftsuspenders.Injector;

public class Player extends Character {

    public static const MS_BETWEEN_TELEPORT:int = 10000;
    private static const MOVE_THRESHOLD:Number = 0.4;
    private static const NEARBY:Vector.<Point> = new <Point>[new Point(0, 0), new Point(1, 0), new Point(0, 1), new Point(1, 1)];
    private static const RANK_OFFSET_MATRIX:Matrix = new Matrix(1, 0, 0, 1, 2, 2);
    private static const NAME_OFFSET_MATRIX:Matrix = new Matrix(1, 0, 0, 1, 20, 1);
    private static const MIN_MOVE_SPEED:Number = 0.004;
    private static const MAX_MOVE_SPEED:Number = 0.0096;
    private static const MIN_ATTACK_MULT:Number = 0.5;
    private static const MAX_ATTACK_MULT:Number = 2;
    private static const LOW_HEALTH_CT_OFFSET:int = 128;

    private static var lowHealthCT:Dictionary = new Dictionary();
    public static var empiresCoin_:int = 0;
    public static var accountType_:int = 0;
    public static var isAdmin:Boolean = false;
    public static var isMod:Boolean = false;
    private static var newP:Point = new Point();

    public var petObjectId:int = 0;
    public var petHpHealingAverageMin:int = 0;
    public var petHpHealingAverageMax:int = 0;
    public var petHpHealingAverageBonus:int = 0;
    public var petMpHealingAverageMin:int = 0;
    public var petMpHealingAverageMax:int = 0;
    public var petMpHealingAverageBonus:int = 0;
    public var petAttackCooldown:int = 0;
    public var petAttackChance:int = 0;
    public var petAttackDamageMin:int = 0;
    public var petAttackDamageMax:int = 0;

    public var isTrading:Boolean = false;
    public var xpTimer:int;
    public var skinId:int;
    public var skin:AnimatedChar;
    public var isShooting:Boolean;
    public var accountId_:String = """";
    public var credits_:int = 0;
    public var tokens_:int = 0;
    public var numStars_:int = 0;
    public var fame_:int = 0;
    public var nameChosen_:Boolean = false;
    public var currFame_:int = 0;
    public var nextClassQuestFame_:int = -1;
    public var guildName_:String = null;
    public var guildRank_:int = -1;
    public var isFellowGuild_:Boolean = false;
    public var breath_:int = -1;
    public var maxMP_:int = 200;
    public var mp_:Number = 0;
    public var nextLevelExp_:int = 1000;
    public var exp_:int = 0;
    public var attack_:String = null;
    public var speed_:String = null;
    public var dexterity_:String = null;
    public var vitality_:String = null;
    public var wisdom_:String = null;
    public var maxHPBoost_:String = null;
    public var maxMPBoost_:String = null;
    public var attackBoost_:String = null;
    public var defenseBoost_:String = null;
    public var speedBoost_:String = null;
    public var vitalityBoost_:String = null;
    public var wisdomBoost_:String = null;
    public var dexterityBoost_:String = null;
    public var xpBoost_:int = 0;
    public var healthPotionCount_:int = 0;
    public var magicPotionCount_:int = 0;
    public var attackMax_:int = 0;
    public var defenseMax_:int = 0;
    public var speedMax_:int = 0;
    public var dexterityMax_:int = 0;
    public var vitalityMax_:int = 0;
    public var wisdomMax_:int = 0;
    public var maxHPMax_:int = 0;
    public var maxMPMax_:int = 0;
    public var hasBackpack_:Boolean = false;
    public var accountType_:int = 0;
    public var admin_:Boolean = false;
    public var starred_:Boolean = false;
    public var ignored_:Boolean = false;
    public var distSqFromThisPlayer_:Number = 0;
    protected var rotate_:Number = 0;
    protected var relMoveVec_:Point = null;
    protected var moveMultiplier_:Number = 1;
    public var attackPeriod_:Number = 0;
    public var attackAmount_:int = 0;
    public var isDazed_:Boolean = false;
    public var isBerserk_:Boolean = false;
    public var minAttackFrequency_:Number = 0;
    public var maxAttackFrequency_:Number = 0;
    public var weaponRateOfFire_:Number = 0;
    public var nextAltAttack_:int = 0;
    public var nextTeleportAt_:int = 0;
    public var dropBoost:int = 0;
    public var tierBoost:int = 0;
    protected var healingEffect_:HealingEffect = null;
    protected var nearestMerchant_:Merchant = null;
    public var isDefaultAnimatedChar:Boolean = true;
    public var projectileIdSetOverrideNew:String = """";
    public var projectileIdSetOverrideOld:String = """";
    private var addTextLine:AddTextLineSignal;
    private var factory:CharacterFactory;
    private var ip_:IntPoint;
    private var breathBackFill_:GraphicsSolidFill = null;
    private var breathBackPath_:GraphicsPath = null;
    private var breathFill_:GraphicsSolidFill = null;
    private var breathPath_:GraphicsPath = null;
    private var hallucinatingMaskedImage_:MaskedImage = null;
    private var slideVec_:Vector3D;

    public function Player(_arg1:XML) {
        this.minAttackFrequency_ = 0.0015;
        this.maxAttackFrequency_ = 0.008;
        this.ip_ = new IntPoint();
        var _local2:Injector = StaticInjectorContext.getInjector();
        this.addTextLine = _local2.getInstance(AddTextLineSignal);
        this.factory = _local2.getInstance(CharacterFactory);
        super(_arg1);
        this.attackMax_ = int(_arg1.Attack.@max);
        this.defenseMax_ = int(_arg1.Defense.@max);
        this.speedMax_ = int(_arg1.Speed.@max);
        this.dexterityMax_ = int(_arg1.Dexterity.@max);
        this.vitalityMax_ = int(_arg1.HpRegen.@max);
        this.wisdomMax_ = int(_arg1.MpRegen.@max);
        this.maxHPMax_ = int(_arg1.MaxHitPoints.@max);
        this.maxMPMax_ = int(_arg1.MaxMagicPoints.@max);
        texturingCache_ = new Dictionary();
        this.slideVec_ = new Vector3D();
    }

    public static function fromPlayerXML(name:String, playerXML:XML):Player {
        var _local3:int = int(playerXML.ObjectType);
        var _local4:XML = ObjectLibrary.xmlLibrary_[_local3];
        var _local5:Player = new Player(_local4);
        _local5.name_ = name;
        _local5.level_ = int(playerXML.Level);
        _local5.exp_ = int(playerXML.Exp);
        _local5.equipment_ = ConversionUtil.toIntVector(playerXML.Equipment);
        _local5.calculateStatBoosts();
        _local5.lockedSlot = new Vector.<int>(_local5.equipment_.length);
        _local5.maxHP_ = (Parameters.parse(_local5.maxHPBoost_) + int(playerXML.MaxHitPoints));
        _local5.hp_ = int(playerXML.HitPoints);
        _local5.maxMP_ = (Parameters.parse(_local5.maxMPBoost_) + int(playerXML.MaxMagicPoints));
        _local5.mp_ = int(playerXML.MagicPoints);
        _local5.attack_ = (Parameters.parse(_local5.attackBoost_) + int(playerXML.Attack)).toString();
        _local5.defense_ = (Parameters.parse(_local5.defenseBoost_) + int(playerXML.Defense)).toString();
        _local5.speed_ = (Parameters.parse(_local5.speedBoost_) + int(playerXML.Speed)).toString();
        _local5.dexterity_ = (Parameters.parse(_local5.vitalityBoost_) + int(playerXML.Dexterity)).toString();
        _local5.vitality_ = (Parameters.parse(_local5.wisdomBoost_) + int(playerXML.HpRegen)).toString();
        _local5.wisdom_ = (Parameters.parse(_local5.dexterityBoost_) + int(playerXML.MpRegen)).toString();
        _local5.tex1Id_ = int(playerXML.Tex1);
        _local5.tex2Id_ = int(playerXML.Tex2);
        _local5.hasBackpack_ = int(playerXML.HasBackpack) != 0;
        return (_local5);
    }

    public function calculateStatBoosts():void {
        var _local2:int;
        var _local3:XML;
        var _local4:XML;
        var _local5:int;
        var _local6:int;
        this.maxHPBoost_ = ""0"";
        this.maxMPBoost_ = ""0"";
        this.attackBoost_ = ""0"";
        this.defenseBoost_ = ""0"";
        this.speedBoost_ = ""0"";
        this.vitalityBoost_ = ""0"";
        this.wisdomBoost_ = ""0"";
        this.dexterityBoost_ = ""0"";
        var _local1:uint;
        while (_local1 < GeneralConstants.NUM_EQUIPMENT_SLOTS) {
            if (((equipment_) && ((equipment_.length > _local1)))) {
                _local2 = equipment_[_local1];
                if (_local2 != -1) {
                    _local3 = ObjectLibrary.xmlLibrary_[_local2];
                    if (((!((_local3 == null))) && (_local3.hasOwnProperty(""ActivateOnEquip"")))) {
                        for each (_local4 in _local3.ActivateOnEquip) {
                            if (_local4.toString() == ""IncrementStat"") {
                                _local5 = int(_local4.@stat);
                                _local6 = int(_local4.@amount);
                                switch (_local5) {
                                    case StatData.MAX_HP_STAT:
                                        this.maxHPBoost_ = (this.maxHPBoost_ + _local6);
                                        break;
                                    case StatData.MAX_MP_STAT:
                                        this.maxMPBoost_ = (this.maxMPBoost_ + _local6);
                                        break;
                                    case StatData.ATTACK_STAT:
                                        this.attackBoost_ = (Parameters.parse(this.attackBoost_) + _local6).toString();
                                        break;
                                    case StatData.DEFENSE_STAT:
                                        this.defenseBoost_ = (Parameters.parse(this.defenseBoost_) + _local6).toString();
                                        break;
                                    case StatData.SPEED_STAT:
                                        this.speedBoost_ = (Parameters.parse(this.speedBoost_) + _local6).toString();
                                        break;
                                    case StatData.VITALITY_STAT:
                                        this.vitalityBoost_ = (Parameters.parse(this.vitalityBoost_) + _local6).toString();
                                        break;
                                    case StatData.WISDOM_STAT:
                                        this.wisdomBoost_ = (Parameters.parse(this.wisdomBoost_) + _local6).toString();
                                        break;
                                    case StatData.DEXTERITY_STAT:
                                        this.dexterityBoost_ = (Parameters.parse(this.dexterityBoost_) + _local6).toString();
                                        break;
                                }
                            }
                        }
                    }
                }
            }
            _local1++;
        }
    }

    public function setRelativeMovement(_arg1:Number, _arg2:Number, _arg3:Number):void {
        var _local4:Number;
        if (this.relMoveVec_ == null) {
            this.relMoveVec_ = new Point();
        }
        this.rotate_ = _arg1;
        this.relMoveVec_.x = _arg2;
        this.relMoveVec_.y = _arg3;
        if (isConfused()) {
            _local4 = this.relMoveVec_.x;
            this.relMoveVec_.x = -(this.relMoveVec_.y);
            this.relMoveVec_.y = -(_local4);
            this.rotate_ = -(this.rotate_);
        }
    }

    public function setCredits(_arg1:int):void {
        this.credits_ = _arg1;
    }

    public function setTokens(_arg1:int):void {
        this.tokens_ = _arg1;
    }

    public function setGuildName(_arg1:String):void {
        var _local3:GameObject;
        var _local4:Player;
        var _local5:Boolean;
        this.guildName_ = _arg1;
        var _local2:Player = map_.player_;
        if (_local2 == this) {
            for each (_local3 in map_.goDict_) {
                _local4 = (_local3 as Player);
                if (((!((_local4 == null))) && (!((_local4 == this))))) {
                    _local4.setGuildName(_local4.guildName_);
                }
            }
        }
        else {
            _local5 = ((((((!((_local2 == null))) && (!((_local2.guildName_ == null))))) && (!((_local2.guildName_ == """"))))) && ((_local2.guildName_ == this.guildName_)));
            if (_local5 != this.isFellowGuild_) {
                this.isFellowGuild_ = _local5;
                nameBitmapData_ = null;
            }
        }
    }

    public function isTeleportEligible(_arg1:Player):Boolean {
        return (!(((_arg1.isPaused()) || (_arg1.isInvisible()))));
    }

    public function msUtilTeleport():int {
        var _local1:int = getTimer();
        return (Math.max(0, (this.nextTeleportAt_ - _local1)));
    }

    public function teleportTo(_arg1:Player):Boolean {
        if (isPaused()) {
            this.addTextLine.dispatch(this.makeErrorMessage(TextKey.PLAYER_NOTELEPORTWHILEPAUSED));
            return (false);
        }
        var _local2:int = this.msUtilTeleport();
        if (_local2 > 0) {
            this.addTextLine.dispatch(this.makeErrorMessage(TextKey.PLAYER_TELEPORT_COOLDOWN, {""seconds"": int(((_local2 / 1000) + 1))}));
            return (false);
        }
        if (!this.isTeleportEligible(_arg1)) {
            if (_arg1.isInvisible()) {
                this.addTextLine.dispatch(this.makeErrorMessage(TextKey.TELEPORT_INVISIBLE_PLAYER, {""player"": _arg1.name_}));
            }
            else {
                this.addTextLine.dispatch(this.makeErrorMessage(TextKey.PLAYER_TELEPORT_TO_PLAYER, {""player"": _arg1.name_}));
            }
            return (false);
        }
        map_.gs_.gsc_.playerText(""/teleport "" + _arg1.name_);
        this.nextTeleportAt_ = (getTimer() + MS_BETWEEN_TELEPORT);
        return (true);
    }

    private function makeErrorMessage(_arg1:String, _arg2:Object = null):ChatMessage {
        return (ChatMessage.make(Parameters.ERROR_CHAT_NAME, _arg1, -1, -1, """", false, _arg2));
    }

    public function levelUpEffect(_arg1:String, _arg2:Boolean = true):void {
        if (_arg2) {
            this.levelUpParticleEffect();
        }
        var _local3:QueuedStatusText = new QueuedStatusText(this, new LineBuilder().setParams(_arg1), 0xFF00, 2000);
        map_.mapOverlay_.addQueuedText(_local3);
    }

    public function handleLevelUp(_arg1:Boolean):void {
        SoundEffectLibrary.play(""level_up"");
        if (_arg1) {
            this.levelUpEffect(TextKey.PLAYER_NEWCLASSUNLOCKED, false);
            this.levelUpEffect(TextKey.PLAYER_LEVELUP);
        }
        else {
            this.levelUpEffect(TextKey.PLAYER_LEVELUP);
        }
    }

    public function levelUpParticleEffect(_arg1:uint = 0xFF00FF00):void {
        map_.addObj(new LevelUpEffect(this, _arg1, 20), x_, y_);
    }

    public function handleExpUp(_arg1:int):void {
        if (level_ == 20) {
            return;
        }
        var _local2:CharacterStatusText = new CharacterStatusText(this, 0xFF00, 1000);
        _local2.setStringBuilder(new LineBuilder().setParams(TextKey.PLAYER_EXP, {""exp"": _arg1}));
        map_.mapOverlay_.addStatusText(_local2);
    }

    private function getNearbyMerchant():Merchant {
        var _local3:Point;
        var _local4:Merchant;
        var _local1:int = ((((x_ - int(x_))) > 0.5) ? 1 : -1);
        var _local2:int = ((((y_ - int(y_))) > 0.5) ? 1 : -1);
        for each (_local3 in NEARBY) {
            this.ip_.x_ = (x_ + (_local1 * _local3.x));
            this.ip_.y_ = (y_ + (_local2 * _local3.y));
            _local4 = map_.merchLookup_[this.ip_];
            if (_local4 != null) {
                return ((((PointUtil.distanceSquaredXY(_local4.x_, _local4.y_, x_, y_) < 1)) ? _local4 : null));
            }
        }
        return (null);
    }

    public function walkTo(_arg1:Number, _arg2:Number):Boolean {
        this.modifyMove(_arg1, _arg2, newP);
        return (this.moveTo(newP.x, newP.y));
    }

    override public function moveTo(_arg1:Number, _arg2:Number):Boolean {
        var _local3:Boolean = super.moveTo(_arg1, _arg2);
        if (map_.gs_.evalIsNotInCombatMapArea()) {
            this.nearestMerchant_ = this.getNearbyMerchant();
        }
        return (_local3);
    }

    public function modifyMove(_arg1:Number, _arg2:Number, _arg3:Point):void {
        if (((isParalyzed()) || (isPetrified()))) {
            _arg3.x = x_;
            _arg3.y = y_;
            return;
        }
        var _local4:Number = (_arg1 - x_);
        var _local5:Number = (_arg2 - y_);
        if ((((((((_local4 < MOVE_THRESHOLD)) && ((_local4 > -(MOVE_THRESHOLD))))) && ((_local5 < MOVE_THRESHOLD)))) && ((_local5 > -(MOVE_THRESHOLD))))) {
            this.modifyStep(_arg1, _arg2, _arg3);
            return;
        }
        var _local6:Number = (MOVE_THRESHOLD / Math.max(Math.abs(_local4), Math.abs(_local5)));
        var _local7:Number = 0;
        _arg3.x = x_;
        _arg3.y = y_;
        var _local8:Boolean;
        while (!(_local8)) {
            if ((_local7 + _local6) >= 1) {
                _local6 = (1 - _local7);
                _local8 = true;
            }
            this.modifyStep((_arg3.x + (_local4 * _local6)), (_arg3.y + (_local5 * _local6)), _arg3);
            _local7 = (_local7 + _local6);
        }
    }

    public function modifyStep(_arg1:Number, _arg2:Number, _arg3:Point):void {
        var _local6:Number;
        var _local7:Number;
        var _local4:Boolean = ((((((x_ % 0.5) == 0)) && (!((_arg1 == x_))))) || (!((int((x_ / 0.5)) == int((_arg1 / 0.5))))));
        var _local5:Boolean = ((((((y_ % 0.5) == 0)) && (!((_arg2 == y_))))) || (!((int((y_ / 0.5)) == int((_arg2 / 0.5))))));
        if (((((!(_local4)) && (!(_local5)))) || (this.isValidPosition(_arg1, _arg2)))) {
            _arg3.x = _arg1;
            _arg3.y = _arg2;
            return;
        }
        if (_local4) {
            _local6 = (((_arg1) > x_) ? (int((_arg1 * 2)) / 2) : (int((x_ * 2)) / 2));
            if (int(_local6) > int(x_)) {
                _local6 = (_local6 - 0.01);
            }
        }
        if (_local5) {
            _local7 = (((_arg2) > y_) ? (int((_arg2 * 2)) / 2) : (int((y_ * 2)) / 2));
            if (int(_local7) > int(y_)) {
                _local7 = (_local7 - 0.01);
            }
        }
        if (!_local4) {
            _arg3.x = _arg1;
            _arg3.y = _local7;
            if (((!((square_ == null))) && (!((square_.props_.slideAmount_ == 0))))) {
                this.resetMoveVector(false);
            }
            return;
        }
        if (!_local5) {
            _arg3.x = _local6;
            _arg3.y = _arg2;
            if (((!((square_ == null))) && (!((square_.props_.slideAmount_ == 0))))) {
                this.resetMoveVector(true);
            }
            return;
        }
        var _local8:Number = (((_arg1) > x_) ? (_arg1 - _local6) : (_local6 - _arg1));
        var _local9:Number = (((_arg2) > y_) ? (_arg2 - _local7) : (_local7 - _arg2));
        if (_local8 > _local9) {
            if (this.isValidPosition(_arg1, _local7)) {
                _arg3.x = _arg1;
                _arg3.y = _local7;
                return;
            }
            if (this.isValidPosition(_local6, _arg2)) {
                _arg3.x = _local6;
                _arg3.y = _arg2;
                return;
            }
        }
        else {
            if (this.isValidPosition(_local6, _arg2)) {
                _arg3.x = _local6;
                _arg3.y = _arg2;
                return;
            }
            if (this.isValidPosition(_arg1, _local7)) {
                _arg3.x = _arg1;
                _arg3.y = _local7;
                return;
            }
        }
        _arg3.x = _local6;
        _arg3.y = _local7;
    }

    private function resetMoveVector(_arg1:Boolean):void {
        moveVec_.scaleBy(-0.5);
        if (_arg1) {
            moveVec_.y = (moveVec_.y * -1);
        }
        else {
            moveVec_.x = (moveVec_.x * -1);
        }
    }

    public function isValidPosition(_arg1:Number, _arg2:Number):Boolean {
        var _local3:Square = map_.getSquare(_arg1, _arg2);
        if (((!((square_ == _local3))) && ((((_local3 == null)) || (!(_local3.isWalkable())))))) {
            return (false);
        }
        var _local4:Number = (_arg1 - int(_arg1));
        var _local5:Number = (_arg2 - int(_arg2));
        if (_local4 < 0.5) {
            if (this.isFullOccupy((_arg1 - 1), _arg2)) {
                return (false);
            }
            if (_local5 < 0.5) {
                if (((this.isFullOccupy(_arg1, (_arg2 - 1))) || (this.isFullOccupy((_arg1 - 1), (_arg2 - 1))))) {
                    return (false);
                }
            }
            else {
                if (_local5 > 0.5) {
                    if (((this.isFullOccupy(_arg1, (_arg2 + 1))) || (this.isFullOccupy((_arg1 - 1), (_arg2 + 1))))) {
                        return (false);
                    }
                }
            }
        }
        else {
            if (_local4 > 0.5) {
                if (this.isFullOccupy((_arg1 + 1), _arg2)) {
                    return (false);
                }
                if (_local5 < 0.5) {
                    if (((this.isFullOccupy(_arg1, (_arg2 - 1))) || (this.isFullOccupy((_arg1 + 1), (_arg2 - 1))))) {
                        return (false);
                    }
                }
                else {
                    if (_local5 > 0.5) {
                        if (((this.isFullOccupy(_arg1, (_arg2 + 1))) || (this.isFullOccupy((_arg1 + 1), (_arg2 + 1))))) {
                            return (false);
                        }
                    }
                }
            }
            else {
                if (_local5 < 0.5) {
                    if (this.isFullOccupy(_arg1, (_arg2 - 1))) {
                        return (false);
                    }
                }
                else {
                    if (_local5 > 0.5) {
                        if (this.isFullOccupy(_arg1, (_arg2 + 1))) {
                            return (false);
                        }
                    }
                }
            }
        }
        return (true);
    }

    public function isFullOccupy(_arg1:Number, _arg2:Number):Boolean {
        var _local3:Square = map_.lookupSquare(_arg1, _arg2);
        return ((((((_local3 == null)) || ((_local3.tileType_ == 0xFF)))) || (((!((_local3.obj_ == null))) && (_local3.obj_.props_.fullOccupy_)))));
    }

    override public function update(currentTime:int, deltaMS:int):Boolean {
        if (this.tierBoost && !isPaused()) {
            this.tierBoost = this.tierBoost - deltaMS;
            if (this.tierBoost < 0) {
                this.tierBoost = 0;
            }
        }
        if (this.dropBoost && !isPaused()) {
            this.dropBoost = this.dropBoost - deltaMS;
            if (this.dropBoost < 0) {
                this.dropBoost = 0;
            }
        }
        if (this.xpTimer && !isPaused()) {
            this.xpTimer = this.xpTimer - deltaMS;
            if (this.xpTimer < 0) {
                this.xpTimer = 0;
            }
        }

        if (isHealing() && !isPaused()) {
            if (this.healingEffect_ == null) {
                this.healingEffect_ = new HealingEffect(this);
                map_.addObj(this.healingEffect_, x_, y_);
            }
        }
        else {
            if (this.healingEffect_ != null) {
                map_.removeObj(this.healingEffect_.objectId_);
                this.healingEffect_ = null;
            }
        }

        var angle:Number = Parameters.data_.cameraAngle;
        if (this.rotate_ != 0) {
            angle = angle + deltaMS * Parameters.PLAYER_ROTATE_SPEED * this.rotate_;
            Parameters.data_.cameraAngle = angle;
        }

        if (map_.player_ == this && isPaused()) {
            return true;
        }

        if (this.relMoveVec_ != null) {
            if (this.relMoveVec_.x != 0 || this.relMoveVec_.y != 0) {
                var mvSpd:Number = this.getMoveSpeed();
                var mvAngle:Number = Math.atan2(this.relMoveVec_.y, this.relMoveVec_.x);
                if (square_.props_.slideAmount_ > 0) {
                    slideVec_.x = mvSpd * Math.cos(angle + mvAngle);
                    slideVec_.y = mvSpd * Math.sin(angle + mvAngle);
                    slideVec_.z = 0;
                    moveVec_.scaleBy(square_.props_.slideAmount_);
                    if (moveVec_.length < slideVec_.length) {
                        slideVec_.scaleBy(1 - square_.props_.slideAmount_);
                        moveVec_ = moveVec_.add(slideVec_);
                    }
                }
                else {
                    moveVec_.x = mvSpd * Math.cos(angle + mvAngle);
                    moveVec_.y = mvSpd * Math.sin(angle + mvAngle);
                }
            }
            else {
                if (moveVec_.length > 0.00012 && square_.props_.slideAmount_ > 0) {
                    moveVec_.scaleBy(square_.props_.slideAmount_);
                }
                else {
                    moveVec_.x = 0;
                    moveVec_.y = 0;
                }
            }
            if (square_ != null && square_.props_.push_) {
                moveVec_.x = moveVec_.x - square_.props_.animate_.dx_ / 1000;
                moveVec_.y = moveVec_.y - square_.props_.animate_.dy_ / 1000;
            }
            this.walkTo(x_ + deltaMS * moveVec_.x, y_ + deltaMS * moveVec_.y);
        }
        else {
            if (!super.update(currentTime, deltaMS)) {
                return false;
            }
        }
        if (map_.player_ == this &&
                square_.props_.maxDamage_ > 0 &&
                (square_.lastDamage_ + 500) < currentTime &&
                !isInvincible() &&
                (square_.obj_ == null || !square_.obj_.props_.protectFromGroundDamage_)) {
            var dmg:int = map_.gs_.gsc_.getNextDamage(square_.props_.minDamage_, square_.props_.maxDamage_);
            var conditionEffects:Vector.<uint> = new Vector.<uint>();
            conditionEffects.push(ConditionEffect.GROUND_DAMAGE);
            damage(-1, dmg, conditionEffects, hp_ <= dmg, null);
            map_.gs_.gsc_.groundDamage(currentTime, x_, y_);
            square_.lastDamage_ = currentTime;
        }
        return true;
    }

    public function onMove():void {
        if (map_ == null) {
            return;
        }
        var _local1:Square = map_.getSquare(x_, y_);
        if (_local1.props_.sinking_) {
            sinkLevel_ = Math.min((sinkLevel_ + 1), Parameters.MAX_SINK_LEVEL);
            this.moveMultiplier_ = (0.1 + ((1 - (sinkLevel_ / Parameters.MAX_SINK_LEVEL)) * (_local1.props_.speed_ - 0.1)));
        }
        else {
            sinkLevel_ = 0;
            this.moveMultiplier_ = _local1.props_.speed_;
        }
    }

    override protected function makeNameBitmapData():BitmapData {
        var _local1:StringBuilder = new StaticStringBuilder(name_);
        var _local2:BitmapTextFactory = StaticInjectorContext.getInjector().getInstance(BitmapTextFactory);
        var _local3:BitmapData = _local2.make(_local1, 16, this.getNameColor(), true, NAME_OFFSET_MATRIX, true);
        _local3.draw(FameUtil.numStarsToIcon(this.numStars_), RANK_OFFSET_MATRIX);
        return (_local3);
    }

    private function getNameColor():uint {
        if (this.isFellowGuild_) {
            return (Parameters.FELLOW_GUILD_COLOR);
        }
        if (this.nameChosen_) {
            return (Parameters.NAME_CHOSEN_COLOR);
        }
        return (0xFFFFFF);
    }

    protected function drawBreathBar(_arg1:Vector.<IGraphicsData>, _arg2:int):void {
        var _local7:Number;
        var _local8:Number;
        if (this.breathPath_ == null) {
            this.breathBackFill_ = new GraphicsSolidFill();
            this.breathBackPath_ = new GraphicsPath(GraphicsUtil.QUAD_COMMANDS, new Vector.<Number>());
            this.breathFill_ = new GraphicsSolidFill(2542335);
            this.breathPath_ = new GraphicsPath(GraphicsUtil.QUAD_COMMANDS, new Vector.<Number>());
        }
        if (this.breath_ <= Parameters.BREATH_THRESH) {
            _local7 = ((Parameters.BREATH_THRESH - this.breath_) / Parameters.BREATH_THRESH);
            this.breathBackFill_.color = MoreColorUtil.lerpColor(0x545454, 0xFF0000, (Math.abs(Math.sin((_arg2 / 300))) * _local7));
        }
        else {
            this.breathBackFill_.color = 0x545454;
        }
        var _local3:int = 20;
        var _local4:int = 8;
        var _local5:int = 6;
        var _local6:Vector.<Number> = (this.breathBackPath_.data as Vector.<Number>);
        _local6.length = 0;
        _local6.push((posS_[0] - _local3), (posS_[1] + _local4), (posS_[0] + _local3), (posS_[1] + _local4), (posS_[0] + _local3), ((posS_[1] + _local4) + _local5), (posS_[0] - _local3), ((posS_[1] + _local4) + _local5));
        _arg1.push(this.breathBackFill_);
        _arg1.push(this.breathBackPath_);
        _arg1.push(GraphicsUtil.END_FILL);
        if (this.breath_ > 0) {
            _local8 = (((this.breath_ / 100) * 2) * _local3);
            this.breathPath_.data.length = 0;
            _local6 = (this.breathPath_.data as Vector.<Number>);
            _local6.length = 0;
            _local6.push((posS_[0] - _local3), (posS_[1] + _local4), ((posS_[0] - _local3) + _local8), (posS_[1] + _local4), ((posS_[0] - _local3) + _local8), ((posS_[1] + _local4) + _local5), (posS_[0] - _local3), ((posS_[1] + _local4) + _local5));
            _arg1.push(this.breathFill_);
            _arg1.push(this.breathPath_);
            _arg1.push(GraphicsUtil.END_FILL);
        }
        GraphicsFillExtra.setSoftwareDrawSolid(this.breathFill_, true);
        GraphicsFillExtra.setSoftwareDrawSolid(this.breathBackFill_, true);
    }

    override public function draw(_arg1:Vector.<IGraphicsData>, _arg2:Camera, _arg3:int):void {
        if (this != map_.player_) {
            if(Parameters.data_.hidePlayers){
                return;
            }
            if (!Parameters.screenShotMode_) {
                drawName(_arg1, _arg2);
            }
        }
        else {
            if (this.breath_ >= 0) {
                this.drawBreathBar(_arg1, _arg3);
            }
        }
        super.draw(_arg1, _arg2, _arg3);
    }

    private function getMoveSpeed():Number {
        if (isSlowed()) {
            return ((MIN_MOVE_SPEED * this.moveMultiplier_));
        }
        var _local1:Number = (MIN_MOVE_SPEED + ((Parameters.parse(this.speed_) / 75) * (MAX_MOVE_SPEED - MIN_MOVE_SPEED)));
        if (((isSpeedy()) || (isNinjaSpeedy()))) {
            _local1 = (_local1 * 1.5);
        }
        return ((_local1 * this.moveMultiplier_));
    }

    public function attackFrequency():Number {
        this.isDazed_ = isDazed();
        this.isBerserk_ = isBerserk();

        if (this.isDazed_)
            return this.minAttackFrequency_;

        var _rateOfFire:Number = this.minAttackFrequency_ + ((Parameters.parse(this.dexterity_) / 75) * (this.maxAttackFrequency_ - this.minAttackFrequency_));

        if (this.isBerserk_)
            _rateOfFire *= 1.5;

        return (_rateOfFire);
    }

    private function attackMultiplier():Number {
        if (isWeak()) {
            return (MIN_ATTACK_MULT);
        }
        var _local1:Number = (MIN_ATTACK_MULT + ((Parameters.parse(this.attack_) / 75) * (MAX_ATTACK_MULT - MIN_ATTACK_MULT)));
        if (isDamaging()) {
            _local1 = (_local1 * 1.5);
        }
        return (_local1);
    }

    private function makeSkinTexture():void {
        var _local1:MaskedImage = this.skin.imageFromAngle(0, AnimatedChar.STAND, 0);
        animatedChar_ = this.skin;
        texture_ = _local1.image_;
        mask_ = _local1.mask_;
        this.isDefaultAnimatedChar = true;
    }

    private function setToRandomAnimatedCharacter():void {
        var _local1:Vector.<XML> = ObjectLibrary.hexTransforms_;
        var _local2:uint = Math.floor((Math.random() * _local1.length));
        var _local3:int = _local1[_local2].@type;
        var _local4:TextureData = ObjectLibrary.typeToTextureData_[_local3];
        texture_ = _local4.texture_;
        mask_ = _local4.mask_;
        animatedChar_ = _local4.animatedChar_;
        this.isDefaultAnimatedChar = false;
    }

    override protected function getTexture(camera:Camera, currentTime:int):BitmapData {
        var pos:Number = 0;
        var action:int = AnimatedChar.STAND;

        if (this.isShooting || currentTime < (attackStart_ + this.attackPeriod_)) {
            facing_ = attackAngle_;
            pos = ((currentTime - attackStart_) % this.attackPeriod_) / this.attackPeriod_;
            action = AnimatedChar.ATTACK;
        }
        else {
            if (moveVec_.x != 0 || moveVec_.y != 0) {
                var movPeriod:int = 3.5 / this.getMoveSpeed();
                if (moveVec_.y != 0 || moveVec_.x != 0) {
                    facing_ = Math.atan2(moveVec_.y, moveVec_.x);
                }
                pos = (currentTime % movPeriod) / movPeriod;
                action = AnimatedChar.WALK;
            }
        }

        if (this.isHexed()) {
            this.isDefaultAnimatedChar && this.setToRandomAnimatedCharacter();
        }
        else {
            if (!this.isDefaultAnimatedChar) {
                this.makeSkinTexture();
            }
        }

        var maskImg:MaskedImage;
        if (camera.isHallucinating_) {
            maskImg = getHallucinatingMaskedImage();
        }
        else {
            maskImg = animatedChar_.imageFromFacing(facing_, camera, action, pos);
        }

        var tex1Id:int = tex1Id_;
        var tex2Id:int = tex2Id_;
        var tex:BitmapData;
        if (this.nearestMerchant_) {
            var merchDict:Dictionary = texturingCache_[this.nearestMerchant_];
            if (merchDict == null) {
                texturingCache_[this.nearestMerchant_] = new Dictionary();
            }
            else {
                tex = merchDict[maskImg];
            }
            tex1Id = this.nearestMerchant_.getTex1Id(tex1Id_);
            tex2Id = this.nearestMerchant_.getTex2Id(tex2Id_);
        }
        else {
            tex = texturingCache_[maskImg];
        }
        if (tex == null) {
            tex = TextureRedrawer.resize(maskImg.image_, maskImg.mask_, size_, false, tex1Id, tex2Id);
            if (this.nearestMerchant_ != null) {
                texturingCache_[this.nearestMerchant_][maskImg] = tex;
            }
            else {
                texturingCache_[maskImg] = tex;
            }
        }

        if (hp_ < maxHP_ * 0.2) {
            var intensity:Number = int(Math.abs(Math.sin(currentTime / 200)) * 10) / 10;
            var ct:ColorTransform = lowHealthCT[intensity];
            if (ct == null) {
                ct = new ColorTransform(1, 1, 1, 1,
                        intensity * LOW_HEALTH_CT_OFFSET,
                        -intensity * LOW_HEALTH_CT_OFFSET,
                        -intensity * LOW_HEALTH_CT_OFFSET);
                lowHealthCT[intensity] = ct;
            }
            tex = CachingColorTransformer.transformBitmapData(tex, ct);
        }

        var plrTex:BitmapData = texturingCache_[tex];
        if (plrTex == null) {
            plrTex = GlowRedrawer.outlineGlow(tex, this.glowColor_);
            texturingCache_[tex] = plrTex;
        }
        if (isPaused() || isStasis() || isPetrified()) {
            plrTex = CachingColorTransformer.filterBitmapData(plrTex, PAUSED_FILTER);
        }
        else {
            if (isInvisible()) {
                plrTex = CachingColorTransformer.alphaBitmapData(plrTex, 40);
            }
        }
        return plrTex;
    }

    private function getHallucinatingMaskedImage():MaskedImage {
        if (hallucinatingMaskedImage_ == null) {
            hallucinatingMaskedImage_ = new MaskedImage(getHallucinatingTexture(), null);
        }
        return hallucinatingMaskedImage_;
    }

    override public function getPortrait():BitmapData {
        var _local1:MaskedImage;
        var _local2:int;
        if (portrait_ == null) {
            _local1 = animatedChar_.imageFromDir(AnimatedChar.RIGHT, AnimatedChar.STAND, 0);
            _local2 = ((4 / _local1.image_.width) * 100);
            portrait_ = TextureRedrawer.resize(_local1.image_, _local1.mask_, _local2, true, tex1Id_, tex2Id_);
            portrait_ = GlowRedrawer.outlineGlow(portrait_, 0);
        }
        return (portrait_);
    }

    public function useAltWeapon(_arg1:Number, _arg2:Number, _arg3:int):Boolean {
        var _local7:XML;
        var _local8:int;
        var _local9:Number;
        var _local10:int;
        var _local11:int;
        if ((((map_ == null)) || (isPaused()))) {
            return (false);
        }
        var _local4:int = equipment_[1];
        if (_local4 == -1) {
            return (false);
        }
        var _local5:XML = ObjectLibrary.xmlLibrary_[_local4];
        if ((((_local5 == null)) || (!(_local5.hasOwnProperty(""Usable""))))) {
            return (false);
        }
        var _local6:Point = map_.pSTopW(_arg1, _arg2);
        if (_local6 == null) {
            SoundEffectLibrary.play(""error"");
            return (false);
        }
        for each (_local7 in _local5.Activate) {
            if (_local7.toString() == ActivationType.TELEPORT) {
                if (!this.isValidPosition(_local6.x, _local6.y)) {
                    SoundEffectLibrary.play(""error"");
                    return (false);
                }
            }
        }
        _local8 = getTimer();
        if (_arg3 == UseType.START_USE) {
            if (_local8 < this.nextAltAttack_) {
                SoundEffectLibrary.play(""error"");
                return (false);
            }
            _local10 = int(_local5.MpCost);
            if (_local10 > this.mp_) {
                SoundEffectLibrary.play(""no_mana"");
                return (false);
            }
            _local11 = 500;
            if (_local5.hasOwnProperty(TextKey.COOLDOWN)) {
                _local11 = (Number(_local5.Cooldown) * NumberKey.COOLDOWNVALUE);
            }
            this.nextAltAttack_ = (_local8 + _local11);

            map_.gs_.gsc_.useItem(_local8, objectId_, 1, _local4, _local6.x, _local6.y, _arg3, isTrading);

            if (_local5.Activate == ActivationType.SHOOT) {
                _local9 = Math.atan2(_arg2, _arg1);
                this.doShoot(_local4, _local5, (Parameters.data_.cameraAngle + _local9), false);
            }
        }
        else {
            if (_local5.hasOwnProperty(""MultiPhase"")) {
                map_.gs_.gsc_.useItem(_local8, objectId_, 1, _local4, _local6.x, _local6.y, _arg3, isTrading);

                _local10 = int(_local5.MpEndCost);
                if (_local10 <= this.mp_) {
                    _local9 = Math.atan2(_arg2, _arg1);
                    this.doShoot(_local4, _local5, (Parameters.data_.cameraAngle + _local9), false);
                }
            }
        }
        return (true);
    }

    public function attemptAttackAngle(_arg1:Number):void {
        this.shoot((Parameters.data_.cameraAngle + _arg1));
    }

    override public function setAttack(_arg1:int, _arg2:Number):void {
        var _local3:XML = ObjectLibrary.xmlLibrary_[_arg1];
        if ((((_local3 == null)) || (!(_local3.hasOwnProperty(TextKey.RATEOFFIRE))))) {
            return;
        }
        var _local4:Number = Number(_local3.RateOfFire);
        this.attackPeriod_ = ((NumberKey.RATEOFFIREVALUE / this.attackFrequency()) * (NumberKey.RATEOFFIREVALUE / _local4));
        super.setAttack(_arg1, _arg2);
    }

    private function shoot(angle:Number):void {
        if (map_ == null || isStunned() || isPaused() || isPetrified())
            return;

        var weapType:int = this.equipment_[0];

        if (weapType == -1)
            return;

        var weapon:XML = ObjectLibrary.xmlLibrary_[weapType];
        var curTime:int = getTimer();

        this.weaponRateOfFire_ = Number(weapon.RateOfFire);
        this.attackPeriod_ = (NumberKey.RATEOFFIREVALUE / this.attackFrequency()) * (NumberKey.RATEOFFIREVALUE / this.weaponRateOfFire_);

        if (curTime < this.attackStart_ + this.attackPeriod_)
            return;

        doneAction(map_.gs_, Tutorial.ATTACK_ACTION);

        this.attackAngle_ = angle;
        this.attackStart_ = curTime;
        this.doShoot(weapType, weapon, attackAngle_, true);
    }

    private function doShoot(weaponType:int, weaponXML:XML, attackAngle:Number, isShooting:Boolean):void {
        var _local11:uint;
        var _local12:Projectile;
        var _local13:int;
        var _local14:int;
        var _local15:Number;
        var _local16:int;
        var arcGap:Number = (weaponXML.hasOwnProperty(TextKey.ARCGAP) ? Number(weaponXML.ArcGap) : NumberKey.ARCGAPVALUE) * Trig.toRadians;
        var _local8:Number = (arcGap * (this.attackAmount_ - 1));
        var _local9:Number = (attackAngle - (_local8 / 2));
        this.isShooting = isShooting;
        this.attackAmount_ = weaponXML.hasOwnProperty(TextKey.NUMPROJECTILES) ? int(weaponXML.NumProjectiles) : NumberKey.NUMPROJECTILESVALUE;
        var _local10:int;
        while (_local10 < this.attackAmount_) {
            _local11 = getBulletId();
            _local12 = (FreeList.newObject(Projectile) as Projectile);
            if (((isShooting) && (!((this.projectileIdSetOverrideNew == """"))))) {
                _local12.reset(weaponType, 0, objectId_, _local11, _local9, this.attackStart_, this.projectileIdSetOverrideNew, this.projectileIdSetOverrideOld);
            }
            else {
                _local12.reset(weaponType, 0, objectId_, _local11, _local9, this.attackStart_);
            }
            _local13 = int(_local12.projProps_.minDamage_);
            _local14 = int(_local12.projProps_.maxDamage_);
            _local15 = ((isShooting) ? this.attackMultiplier() : 1);
            _local16 = (map_.gs_.gsc_.getNextDamage(_local13, _local14) * _local15);
            _local12.setDamage(_local16);
            if ((((_local10 == 0)) && (!((_local12.sound_ == null))))) {
                SoundEffectLibrary.play(_local12.sound_, 0.75, false);
            }
            map_.addObj(_local12, (x_ + (Math.cos(attackAngle) * 0.3)), (y_ + (Math.sin(attackAngle) * 0.3)));
            map_.gs_.gsc_.playerShoot(_local12, this.attackAmount_, this.isDazed_, this.isBerserk_, this.minAttackFrequency_, this.maxAttackFrequency_, this.weaponRateOfFire_);
            _local9 = (_local9 + arcGap);
            _local10++;
        }
    }

    public function isHexed():Boolean {
        return (!(((condition_[ConditionEffect.CE_FIRST_BATCH] & ConditionEffect.HEXED_BIT) == 0)));
    }

    public function isInventoryFull():Boolean {
        if (equipment_ == null) {
            return (false);
        }
        var _local1:int = equipment_.length;
        var _local2:uint = 4;
        while (_local2 < _local1) {
            if (equipment_[_local2] <= 0) {
                return (false);
            }
            _local2++;
        }
        return (true);
    }

    public function nextAvailableInventorySlot():int {
        var _local1:int = ((this.hasBackpack_) ? equipment_.length : (equipment_.length - GeneralConstants.NUM_INVENTORY_SLOTS));
        var _local2:uint = 4;
        while (_local2 < _local1) {
            if (equipment_[_local2] <= 0) {
                return (_local2);
            }
            _local2++;
        }
        return (-1);
    }

    public function numberOfAvailableSlots():int {
        var _local1:int = ((this.hasBackpack_) ? equipment_.length : (equipment_.length - GeneralConstants.NUM_INVENTORY_SLOTS));
        var _local2:int;
        var _local3:uint = 4;
        while (_local3 < _local1) {
            if (equipment_[_local3] <= 0) {
                _local2++;
            }
            _local3++;
        }
        return (_local2);
    }

    public function swapInventoryIndex(_arg1:String):int {
        var _local2:int;
        var _local3:int;
        if (!this.hasBackpack_) {
            return (-1);
        }
        if (_arg1 == TabStripModel.BACKPACK) {
            _local2 = GeneralConstants.NUM_EQUIPMENT_SLOTS;
            _local3 = (GeneralConstants.NUM_EQUIPMENT_SLOTS + GeneralConstants.NUM_INVENTORY_SLOTS);
        }
        else {
            _local2 = (GeneralConstants.NUM_EQUIPMENT_SLOTS + GeneralConstants.NUM_INVENTORY_SLOTS);
            _local3 = equipment_.length;
        }
        var _local4:uint = _local2;
        while (_local4 < _local3) {
            if (equipment_[_local4] <= 0) {
                return (_local4);
            }
            _local4++;
        }
        return (-1);
    }

    public function getPotionCount(_arg1:int):int {
        switch (_arg1) {
            case PotionInventoryModel.HEALTH_POTION_ID:
                return (this.healthPotionCount_);
            case PotionInventoryModel.MAGIC_POTION_ID:
                return (this.magicPotionCount_);
        }
        return (0);
    }

    public function getTex1():int {
        return (tex1Id_);
    }

    public function getTex2():int {
        return (tex2Id_);
    }


}
}
",12135,False,2139.416262678996,median
"/************************************************************************
 *  Main entry points.
 *  These are functions that are called directly from event handlers.
 ************************************************************************/

/* TODO:
 * cut using a polygonal path, not just a single line segment
 * truly cut - remove one polygon after cutting.  Add action buttons for
 *  cut, burn, fold, unfold and cancel.
 *   UI sequences: 
 *    cut: (1) press cut button.  (2) draw path. (3) press ok or cancel. 
 *      (polygons severed)
 *    burn: (1) press burn button. (2) click on a polygon.  (polygon burnt).
 *    fold: (1) press crease button. (2) draw single line segment. 
 *    (3) select fold up or down and then a polygon or cancel.
 *    unfold: (1) press unfold button - (snowflake is revealed).  
 *    Or - unfold one step at a time?
 * nice touches: iconic buttons and cursor states.  
 *   fold/unfold animation.  patterned paper?
 * 
 */
 
/*
 * for a production version: remove debugging code (incl. poly id, fold.poly); 
 * merge
 * flags into bitfield.  maybe could optimize the marking algorithm to only
 * mark polys that do need to be flipped?
 */
 
/* 	init()
 * Called when the script starts.  Creates the paper movieclip that
 * contains all the polygon data structures.  The canvas movieclip exists
 * only to enforce the proper stacking order (so the cursor will be on top
 * of the paper).  
 */
 
function init()
{
    // data structure initialization
    canvas.polys = [];
    canvas.zlevels = 1;
    canvas.fold_level = 0;
    canvas.next_poly_id = 0;
    error = false;
    with (canvas) {
	var last = new Point(100, 20);
	var v = new Point(100, 380, last);
	v = new Point(460, 380, v);
	v = new Point(460, 20, v);
	var square = new Poly();
	square.points = v;
	last.next = v;
	polys.push(square);
        getModelBounds (polys, true);
	drawModel (canvas);
    }
    colors = new Array (0x444433, 0x554433, 0x663344, 0x446633, 0x333366,
                        0x666666, 0x884488, 0x992222, 0x229922, 0x222299);
}

function setCursor (clip)
// set (or clear) a custom cursor
{
    if (cursor.cursorclip) 
        cursor.cursorclip._visible = false;
    if (clip) {
        Mouse.hide ();
        cursor.cursorclip = clip;
        clip._x = _root._xmouse;
        clip._y = _root._ymouse;
        clip._visible = true;
    } else {
        Mouse.show ();
    }
}

function printModel ()
{
    print (""canvas"", ""bframe"");
}

/* foldModel (x1, y1, x2, y2)
 *
 * folds (reflects, flips and raises/lowers in stacking order) a set
 * of polygons intersected by a line segment.  Note: there is a problem
 * with this in that it allows polygons to be folded ""through"" each other.
 * This can be prevented by requiring the line segment to begin and end
 * outside the polygons (I think).  Or it might be possible to detect the
 * obstruction of a folding poly by another poly above or below it that is
 * not being folded.  In this case we could either prevent the fold or
 * possibly ""tuck"" the fold in an interior layer.  In any case all that
 * stuff would require a bunch of expensive geometry. 
 *
 *   Each of the polygons in the model is tested for intersection with the line segment,
 *   and possibly split.
 *   foldPoly will fold polygons using a right-hand rule.
 *   After being split, the halves to the right of the fold line are folded
 *   underneath (they are reflected about the fold line and have their z-value reflected
 *   around the (new) central z value.
 */


function foldModel (x1, y1, x2, y2)
{
    /*
    var v1 = { x: x1-1.5, y : y1-2.5 } ;
    var v2 = { x: x2-1.5, y : y2-2.5 } ;
    */
    var v1 = { x: x1, y : y1 } ;
    var v2 = { x: x2, y : y2 } ;
    canvas.globalToLocal (v1);
    canvas.globalToLocal (v2);
    v1 = new Point (v1.x, v1.y);
    v2 = new Point (v2.x, v2.y);
    // trace (""fold "" + x1 +"","" + y1 + ""->""+x2+"",""+y2);

    var new_polys = [];
    var npolys = canvas.polys.length;
    var i;
    // trace (""foldModel: "" + npolys );
    // dumpPolys (canvas.polys);
    for (i = 0; i < npolys; i++) {
        // trace (""splitPoly "" +canvas.polys[i].id);
        foldPoly (canvas.polys[i], v1, v2, new_polys, canvas.fold_level + 1);
        /*
        dumpPolys (canvas.polys);
        trace (""new polys:"");
        dumpPolys (new_polys);
        */
    }
    if (new_polys.length <= 0)
        return;
    for (i = 0; i<new_polys.length; i++) {
        canvas.polys.push (new_polys[i]);
    }

    // traverse the polygon graph, propagating the flipme flag to mark the dependent
    // polygons to be folded.
    markPolyTree (new_polys[0], new_polys[0].flipping, null, canvas.fold_level + 1);
    canvas.zlevels *= 2;
    reflectMarkedPolys (canvas.polys, v1, v2, canvas.zlevels);
    clearPolyFlags (canvas.polys);
    canvas.fold_level ++;
    // dumpPolys (canvas.polys);

    getModelBounds (canvas.polys, true);
    // checkModel (canvas.polys);
    drawModel (canvas);
}

/* unfold_once
 * unfolds (reflects, flips and raises/lowers in stacking order) a
 * bottommost polygon.  This function assumes the canvas.polys are
 * sorted in inverse stacking order, which happens when they're drawn.  Not
 * all folds can be unfolded without unfolding others first: However, some
 * folds are ""exterior"" and always unfoldable regardless of the geometry.
 * We first tried to choose one by finding the fold on the bottommost
 * polygon that adjoins the highest neighbor.  Q: is this always
 * unfoldable? Nope.  It seems that because we don't remove folds after
 * they're unfolded (they remain, albeit flattened out, as creases), the
 * bottom-most poly we happen to choose may not actually lie on a fold
 * (just a crease).  So try them all until we find one... 
 */
 
function unfold_once ()
{
    if (canvas.fold_level <= 0) 
        return;
    // trace (""UNFOLD"");

    // this depends on operating in stacking order because of the way we
    // modify the structure as we go.  The ""flipped"" polygons will always
    // show up first (because we always fold down and unfold up).

    var j;
    for (j=0; j<canvas.polys.length; j++)
    {
        if (canvas.polys[j].z < canvas.fold_level / 2)
            break;
    }
    // flip all polys w/z >= canvas.fold_level / 2.
    for (var i=0; i<j; i++) 
    {
        var p = canvas.polys[i];
        var v = p.points;
        do {
            if (v.fold && v.fold.level == canvas.fold_level)
            {
               // reflect the adjacent poly and any ""descendants"" on the same
               // side of the edge v.
                if (!p.flipped)
                {
                    var p1 = v.fold.twin.v1.poly;
                    p.is_anchor = true;
                    p1.is_anchor = true;
                    p1.flipme = false;
                    // trace (""unfolding "" + p.id);

                    markPolySubTree (p, v.fold.level);
                    reflectMarkedPolys 
                        (canvas.polys, v.fold.v1, v.fold.v2, canvas.zlevels);
                }
                // merge this polygon with the one one the other side of the
                // fold (now just a crease).
                removeFold (v.fold);
                // go on to the next poly - this poly no longer exists.
                // If it had multiple folds at this level, the others will be
                // removed when we process its twins
                break;
            }
            v = v.next;
        } while (v != p.points);
    }
    cullEmptyPolys (canvas.polys);
    clearPolyFlags (canvas.polys);
    // checkModel (canvas.polys);
    -- canvas.fold_level;
    canvas.zlevels /= 2;
    getModelBounds (canvas.polys, true);
    drawModel (canvas);
}

function removeFold (f)
{
    /* cut out e, e1 and their folds, and eliminate f.v1.poly */
    var e = f.v1;
    var p = e.poly;
    var e1 = f.twin.v1;
    var p1 = e1.poly;
    // trace (""removeFold "" + p.id + "" merging with "" + p1.id);
    var ep = findPrev (e);
    var e1p = findPrev (e1);
    ep.next = e1.next;
    e1p.next = e.next;
    p1.points = e1p;
    if (ep.fold)                /* fix up neighboring folds */
        ep.fold.v2 = ep.next;
    if (e1p.fold)
        e1p.fold.v2 = e1p.next;
    setPointsPoly (p1);          /* get rid of p by unlinking */
    p.points = null;           /* and marking for later removal */
    
    // trace (""removeFold removing extra folds "");
    e = e1p; do {
        e1 = e.fold.twin.v1;
        if (e.fold && (e1.poly == p || e1.poly == p1)) 
        {
            // it must be the another segment of the fold we are removing
            // if it connects p and p1, so delete the folds associated 
            // with these edges, which are now just a (pair of) internal edges;
            // a slice connecting an interior hole with the exterior, 

            // or in the degenerate case (no hole), remove the edges.
            // TBD: handle cases where the degenerate crease has more than
            // one pair of edges
            if (e.next == e1) {
                e.next = e1.next.next;
                e.fold = null;
            } else if (e1.next == e) {
                e1.next = e.next.next;
                e1.fold = null;
            } else {
                // TBD:  make these edges invisible
                e.fold = null;
                e.is_crease = true;
                e1.fold = null;
                e1.is_crease = true;
            }
        }
        e = e.next;
    } while (e != e1p);
    // trace (""removeFold done "");
}

function cullEmptyPolys (polys)
{
    for (var i = 0; i < polys.length; i++) {
        if (! polys[i].points) {
            polys.splice (i, 1); /* remove the poly */
            --i;
        }
    }
}

function cutSelect (x1, y1, x2, y2)
{
    // trace (""cutSelect "" + x1 + "","" + y1 + ""  "" + x2 + "","" + y2);
    var v1 = { x: x1, y : y1 } ;
    var v2 = { x: x2, y : y2 } ;
    canvas.globalToLocal (v1);
    canvas.globalToLocal (v2);
    v1 = new Point (v1.x, v1.y);
    v2 = new Point (v2.x, v2.y);

    // trace (""line:  "" + v1.x + "","" + v1.y + "" =>  "" + v2.x + "","" + v2.y);
    canvas.moveTo (v1.x, v1.y);
    canvas.lineStyle(0, 0x000000, 100);
    canvas.lineTo (v2.x, v2.y);
    updateAfterEvent ();

    var u = null;
    var v;
    var treturn = {};
    // maybe get all the intersections and just use the closest one?
    for (v = pcut.points; v; v = v.next && !u) {
        u = intersectEdges (v1, v2, v, v.next, true, treturn);
        if (treturn.t <= 0) {
            u = null;
        }
    } 
    
    // create pcut if it doesn't exist yet
    if (!pcut) {
        pcut = new Poly();
        pcut.points = v1;
    }

    var v = pcut.points;
    while (v.next) {  /* find the end of the poly's linked list */
        v = v.next;
    }
    if (!u) {
        // append v2 to pcut
        v.next = v2;
        return false;
    }
    
    // cut as soon as we have a closed poly
    v.next = u;                 /* append u to p */

    // u.next = pcut.points;    /* close the poly*/
    // ???
    u.next = pcut.points.next // eliminate pcut.points to ensure a closed polygon
    pcut.points = u;
    cursor.clear ();
    drawPoly (pcut, canvas);
    cutModel ();
    return true;
}

function cutModel () 
{
    // do cutting
    var npolys = canvas.polys.length;
    var new_polys = [];
    var cut_folds = [];
    var i;
    var new_new_polys = [];
    // dumpPolyBrief (pcut);
    computeBoundingBox (pcut);
    for (i = 0; i < npolys; i++) {
        if (! polysOverlap (canvas.polys[i], pcut)) {
            // a bounding box test
            continue;
        }
        cutPoly (canvas.polys[i], pcut, new_new_polys, cut_folds);
        computeBoundingBox (canvas.polys[i]);
        while (new_new_polys.length) {
            // don't try to cut the new_polys
            new_polys.push (new_new_polys.pop());
        }
    }
    for (i = 0; i < new_polys.length; i++) {
        canvas.polys.push(new_polys[i]);
        computeBoundingBox (new_polys[i]);
    }
    for (i = 0; i < cut_folds.length; i++) {
        patchCutFold (cut_folds[i]);
    }

    getModelBounds (canvas.polys, false);
    drawModel (canvas);
    // dumpPolys (canvas.polys)
    // checkModel (canvas.polys);
    // clear pcut
    pcut = null;
}

/*************************************************************************
 * drawing functions 
 *************************************************************************/

function drawModel(mc)
{
    mc.clear ();
    mc.lineStyle(0, 0x000000, 100);
    // sort in inverse stacking order - draw bottom poly first
    mc.polys.sort(polyStackComparison);
    for (var i = 0; i<mc.polys.length; i++) {
        drawPoly (mc.polys[i], mc);
    }
}

function rescale_canvas ()
{
    // center and scale to fit, assuming screen size 560 x 400 
    var xspan = (canvas.bounds.right - canvas.bounds.left);
    var yspan = (canvas.bounds.bottom - canvas.bounds.top);
    var scale = 100 * (xspan > yspan ? (360 / xspan) : (360 / yspan));
    var newx = 280 - (canvas.bounds.right + canvas.bounds.left) * scale / 200;
    var newy = 200 - (canvas.bounds.bottom + canvas.bounds.top) * scale / 200;
    canvas.scale_delta = (scale-canvas._xscale) / 6;
    canvas.x_delta = (newx-canvas._x) / 6;
    canvas.y_delta = (newy-canvas._y) / 6;
    canvas.rescale_idx = 6;
}

function drawPoly(p, mc) 
{
    var v = p.points;
    if (! v)
        return;
    var scale = 100 / canvas._xscale;
    mc.moveTo(v.x, v.y);
    mc.beginFill(p.faceup ? p.fgcolor : 0xaaaaaa, 70);
    mc.lineStyle(0, 0, 100);
    do {
        if (v.fold)
            canvas.lineStyle(v.fold.level * scale, 0, 100);
        else if (v.is_crease) {
            canvas.lineStyle(0, 0, 0);
        } else {
            canvas.lineStyle(0, 0, 100);
        }
        v = v.next;
        mc.LineTo(v.x, v.y);
    } while (v != p.points);
    mc.endFill();
}

function drawDiamond (v, mc, c)
{
    mc.lineStyle(0, 0x000000, 100);
    mc.beginFill(c, 100);
    mc.moveTo(v.x-3, v.y);
    mc.LineTo(v.x, v.y-3);
    mc.LineTo(v.x+3, v.y);
    mc.LineTo(v.x, v.y+3);
    mc.LineTo(v.x-3, v.y);
    mc.endFill();
}

/*
 * polygon selection
 */

function findPolygon (x, y)
{
    var v = { x: x, y : y } ;
    canvas.globalToLocal (v);
    v = new Point (v.x, v.y);
    canvas.selectedPoly = null;
    for (var i = canvas.polys.length - 1; i >= 0; i--)
    {
        if (containsPoly(canvas.polys[i], v))
        {
            return canvas.polys[i];
        }
    }
}

function discardPolygon (x, y)
{
    var p;
    var found = false;
    while (p = findPolygon (x, y))
    {
        markPolyTree (p, true, null, 0);
        for (var i = 0; i < canvas.polys.length; i++)
        {
            if (canvas.polys[i].flipme) {
                var p = canvas.polys[i];
                canvas.polys.splice (i, 1); /* remove the poly */
                deletePoly (p);
                --i;
                found = true;
            }
        }
    }
    getModelBounds (canvas.polys, false);
    drawModel (canvas);
    return found;
}

function test (x, y) {
    var v = new Point (x, y);
    if (containsPoly (canvas.polys[0], v)) {
        trace (""in"");
    } else {
        trace (""out"");
    }
}

/************************************************************************
 * polygon manipulation: cutting and folding
 ************************************************************************/
 
/*
 * foldPoly splits a polygon in two with a line segment, modifying the
 * argument p and returning a list of any new polygons that are created.
 */

function foldPoly (p, v1, v2, new_polys, fold_level)
{
    var intersections = intersectPoly (p, v1, v2);
    if (intersections.length < 2) {
        return null;	// Ignore snips into the interior that leave the polygon whole
    }
    var inp = contains(p, v1);
    if (inp && intersections.length < 3) {
        return null;	// Ignore snips from the interior to the interior that leave the polygon whole
    }
    if (inp) {
        // ignore the first intersection since it's just incidental if we started inside the polygon
        intersections.shift(); // TBD delete me?
    }
    while (intersections.length > 1) {	 
        /* Create a new poly from one side of the cut (or fold) In the new
        poly, the dividing edge contains the points b, a in the sequence:
        b0->b->a->a.next.  Also modify the existing poly to contain the new
        edge in the sequence: a0->a->b->b0.next */
        var a_int = intersections.shift();
        var a = a_int.pt, a0 = a_int.edge;
        var fa = a0.fold;
		 
        var b_int = intersections.shift();
        var b = b_int.pt, b0 = b_int.edge;
        var fb = b0.fold;
		 
        // trace (""foldPoly a=("" + a.x + "","" + a.y + ""), b=("" + b.x + "","" + b.y + "")"");
        var p1 = copyPoly (p);

        // clone b and a for the new poly and set up the fold structure linking them
        // and their polygons together
        var b1 = copyPoint (b);
        var a1 = copyPoint (a);
        var f = new Fold (p, a, b, fold_level);
        a.fold = f; 
        // b.fold = f;
        var f1 = new Fold (p1, b1, a1, fold_level);
        b1.fold = f1; 
        // a1.fold = f1;
        f1.twin = f;
        f.twin = f1;

        // relink the points to form p1
        b1.next = a1;
        a1.next = a0.next;
        b.next = b0.next; // part of p, not p1 - but do it now to avoid losing the link
        b0.next = b1;
        p1.points = b1;
        new_polys.push (p1);
		 
        // hook up the p points
        a0.next = a;
        a.next = b;
        p.points = a;  // may be redundant, but sometimes needed...
		 
        // set the poly links of all the points in p and p1
        setPointsPoly (p);
        setPointsPoly (p1);
		 
        // mark these polys as having determinate flippedness
        p1.is_anchor = true;
        p.is_anchor = true; 
			 
        // determine which poly is on the right hand side of the fold and mark it.
        if (p.faceup) {
            p.flipme = true;
        } else {
            p1.flipme = true;
        }
        // I checked via dumpPolys and everything looked good after two folds
        // - once widthwise and once lengthwise
         if (fa) {
            if (fa.v1 != a0 || fa.v2 != a1.next) {
                trace (""BARF FA"");
            }
            foldFold (fa, a, a1); // split the fa fold in two
        }
        if (fb) {
            if (fb.v1 != b0 || fb.v2 != b.next) {
                trace (""BARF FB"");
            }
            foldFold (fb, b1, b); // split the fb fold in two
        }
        // dumpPoly (p);
        // dumpPoly (p1);
        delete a_int;  // unnecessary?
        delete b_int;
    }
}
 
function foldFold (f, a, a1)
{
    // split the f fold in two
    var f1 = new Fold (a1.poly, a1, f.v2, f.level);
    f.v2 = a; 
    // a.fold = f;  // no - should be set to the new higher-level fold 
    a1.fold = f1;
    if (f1.v2.fold == f)        /* f.v2.fold is already = f if it should */
        f1.v2.fold = f1;
    if (f.other_twin) {
        // fa's twin has already been split - it left a ptr in f
        f1.twin = f.twin;
        f.twin = f.other_twin;
        // f.twin.twin = f; -- already?
        f1.twin.twin = f1;
        delete f.other_twin;
    } else {
        f1.twin = f.twin; /* for now */
        f.twin.other_twin = f1;
    }
}

/* markPolySubTree */
function markPolySubTree (p, fold_level, parent)
{
    if (p.visited) {
        // trace ( "" markPoly "" + p.id + "" (already)"");
        return;   // stop this thing from going on forever
    }
    p.visited = true;
    p.flipme = true;
    // trace ( "" markPoly marking "" + p.id);
    var v = p.points;
    do {
        var f = v.fold; var p1;
        if (f && (p1 = f.twin.v1.poly) != parent)
        {
            if (f.level != fold_level) {
                // don't cross the fold 
                markPolySubTree (p1, fold_level, p);
            }
        }
        v = v.next;
    } while (v != p.points);
}

/* markPolyTree
  * Walk a graph of polys, following fold_poly links, setting flags 
  */
  
function markPolyTree (p, flipping, parent, fold_level)
{
    if (p.visited) {
        // trace ( "" markPoly "" + p.id + "" (already)"");
        return;   // stop this thing from going on forever
    }
    p.visited = true;
    if (p.is_anchor) {
        // The newly split polygons are like islands of certainty in a sea of doubt...
        flipping = p.flipme;
        // trace ("" markPoly "" + p.id + "" new - set flipping to "" + flipping);
    } else {
        p.flipme = flipping;
        // trace ("" markPoly "" + p.id + "" flipme set to "" + flipping);
    }
    var v = p.points;
    do {
        // recurse through folds, including the current one.
        // the parent test is not strictly necessary - it just saves some useless recursions
        var f = v.fold; var p1;
        if (f && (p1 = f.twin.v1.poly) != parent)
        {
            if (f.level == fold_level) {
                // change flipping when crossing the fold 
                markPolyTree (p1, !flipping, p, fold_level);
            } else {
                markPolyTree (p1, flipping, p, fold_level);
            }
        }
        v = v.next;
    } while (v != p.points);
}

function cutPoly (p, pcut, new_polys, cut_folds)
{
    var v = pcut.points;
    var vout = new Point (-100, -100);
    // trace (""cutPoly "" + p.id);
    // see if v is inside p (and remember a ""nearby"" intersection)
    var inside;
    var outer_xings;
    do {
        outer_xings = intersectPoly (p, vout, v);
        inside = outer_xings.length % 2 == 1;
        if (! inside) 
            break;
        v = v.next;
    } while (v != pcut.points);
    if (inside) {
        // there are no external points...
        // maybe figure this out later
        // trace (""  inside poly "" + p.id + ""; skipping"");
        return;
    }
    /*
    if (v != pcut.points) {
        pcut.points.poly = pcut;
        var prev = findPrev (pcut.points);
        prev.next = pcut.points.next; // eliminate the extra tail on the poly
        pcut.points = v;        // start at an outside point
    }
    */
    pcut.points = v;        /* start at an outside point */

    var nxings = 0;
    var xings = [];
    var pp = null;
    do {
        var vxings, min_dist = 2;
        if (pp) {
            vxings = intersectPoly (pp, v, v.next);
        } else {
            // search for the first poly of our new batch to be intersected by this
            // line segment
            vxings = intersectPoly (p, v, v.next);
            if (vxings.length > 0) {
                min_dist = vxings[0].t;
                pp = p;
            }
            for (var i = 0; i < new_polys.length; i++) {
                var pivxings = intersectPoly (new_polys[i], v, v.next);
                if (pivxings.length > 0 && min_dist > pivxings[0].t) {
                    min_dist = pivxings[0].t;
                    vxings = pivxings;
                    pp = new_polys[i];
                    // TBD - check to be sure we can break here - don't
                    // we need to check them all?
                    break;
                }
            }
        }
        var n = vxings.length;
        nxings += n;
        if (n % 2)
            inside = !inside;
        while (n--) {
            xings.push (vxings.shift());
        }
        while (nxings >= 2) {
            cutPolySegment (pp, xings, new_polys, cut_folds);
            nxings -= 2;
        }
        if (inside) {

             /* no ""edge"" indicates this is not an intersection, but a new interior point
            // be sure to copy the point because it will be incorporated
            // into a new polygon and can't be shared by several */

            xings.push ( { pt: copyPoint(v.next) } );
        }
        if (xings.length == 0) {
            pp = null;
        }
        v = v.next;
    } while (v != pcut.points);
    // now xings has all the intersections of pcut with p plus any points of pcut interior to p.
    /*
    if (new_polys.length == 0) {
       trace (""cutPoly: no new polys?"");
    }
    */
    for (var i = 0; i < new_polys.length; i++) {
        setPointsPoly (p);
        setPointsPoly (new_polys[i]);
    }
}

function cutPolySegment (p, xings, new_polys, cut_folds)
{
    // trace (""cutPolySegment "" + p.id);
    var a, b, a0, b0, a_last, b_last, e, e0;
    var done = false;
    // loop over all intersections and internal points, creating new polygons
    // out of pieces of p.
    while (xings.length > 0 && !done)
    {
        var xing = xings.shift();
        a = copyPoint (xing.pt);
        b = copyPoint (a);
        if (!a0) {
            a0 = a;
            b0 = b;
            if (!xing.edge) 
                trace (""cutPolySegment: first intersection crosses no edge?"");
            e0 = xing.edge;
        } else {
            a_last.next = a;
            b.next = b_last;
            if (xing.edge)
                done = true;
        }
        a_last = a;
        b_last = b;
    }
    
    // now close off the polygons depending on the relationship of the entry
    // and exit points - there are three cases:

    var e = xing.edge;  /* (e, e.next) = intersected edge of p */
    var p1 = copyPoly (p);
    new_polys.push (p1);

    var f = e.fold;
    // TBD !!!: this edge is sometimes spurious because of the temporary 
    // settings we make during the cutting process (see XXX below)

    if (e != e0)
    {   // We entered and exited on different edges.
        // Remember the salient points on the folded edges - before losing
        // the links e/e.next and e0/e0.next
        if (f) {
            pushCutFoldPoint (f, a, p.faceup ? cut_folds : null);
            a.fold = f;         /* XXX */
            //b.fold = f;
        }
        if (f = e0.fold) {
            pushCutFoldPoint (f, b0, p.faceup ? cut_folds : null);
            //a0.fold = f;        /* XXX */
            b0.fold = f;
        }
        // close off the polygons
        b0.next = e0.next;
        e0.next = a0;
        a.next = e.next;
        e.next = b;
    } 
    else                        /* a0,b0 and a,b are on the same edge */
    {
        // If a is further from e0 than a0 then the b's form their own 
        // entirely new polygon, while the a's are connected to the points
        // of the original p.
        if ((Math.abs(a.x-e0.x) + Math.abs(a.y-e0.y)) > 
            (Math.abs(a0.x-e0.x) + Math.abs(a0.y-e0.y)))
        {
            a.next = e0.next;
            b0.next = b;
            e0.next = a0;
        }
        else
        // ... otherwise the a's form the new polygon, and the b's
        // get connected to p.
        {
            a.next = a0;
            b0.next = e0.next;
            e0.next = b;
        }
        if (f) {
            a.fold = f;         /* XXX */
            //a0.fold = f;
            //b.fold = f;
            b0.fold = f;
            pushCutFoldPoint (f, b0, p.faceup ? cut_folds : null);
            pushCutFoldPoint (f, a);
        }
    }
    p.points = a;
    p1.points = b;

    if (!done)
        trace (""cutPolySegment exiting when ! done?"");
}

function pushCutFoldPoint (f, v, cutfolds)
{
    if (! f.cutpoints)
    {
        f.cutpoints = new Array;
        if (cutfolds)
            cutfolds.push (f);
    }
    f.cutpoints.push (v);
}

function patchCutFold (f)
{
    var f1 = f.twin;
    // sanity check:
    if (!f.cutpoints || !f1.cutpoints || f.cutpoints.length != f1.cutpoints.length)
    {
        trace (""patchCutFold: fold mismatch detected"");
        trace (""patchCutFold: f has "" + 
               f.cutpoints.length + "", f1 has "" +
               f1.cutpoints.length);
        trace (""patchCutFold: f=("" +
               Math.round(f.v1.x)+"",""+Math.round(f.v1.y)+""),(""+
               Math.round(f.v2.x)+"",""+Math.round(f.v2.y)+"")""
               + "" f1=("" +
               Math.round(f1.v1.x)+"",""+Math.round(f1.v1.y)+""),(""+
               Math.round(f1.v2.x)+"",""+Math.round(f1.v2.y)+"")""
               );
        drawDiamond (f.v1, cursor, 0xff0000);
        drawDiamond (f.v2, cursor, 0xff0000);
        drawDiamond (f1.v1, cursor, 0x0000ff);
        drawDiamond (f1.v2, cursor, 0x0000ff);
        for (var i=0; i<f.cutpoints.length; i++) {
            drawDiamond (f.cutpoints[i], cursor, 0x00ff00);
        }
        for (var i=0; i<f1.cutpoints.length; i++) {
            drawDiamond (f1.cutpoints[i], cursor, 0x888800);
        }
        return;
    }
    while (f.cutpoints.length > 0)
    {
        var v = f.cutpoints.pop();
        var v1;
        if (v.next == f.v2) {
            // the start point of the original uncut folded edge f1
            // is added implicitly
            v1 = f1.v1;
        } else {
            // search for the matching point in f1's cutpoints
            var i; 
            v1 = null;
            for (i=0; i<f1.cutpoints.length; i++) {
                v1 = f1.cutpoints[i];
                if (peq(v.next, v1)) {
                    f1.cutpoints.splice (i, 1);
                    break;
                }
            }
            if (!v1) {
                trace (""patchCutFold: no matching cut point found"");
            }
        }
        addCutFold (v, v1, f, f1)
    }
    if (f1.cutpoints.length <= 0) {
        trace (""patchCutFold: not enough cutpoints?"");
    }
    // the start point of the original uncut folded edge f is added implicitly
    addCutFold (f.v1, f1.cutpoints.pop(), f, f1);
    if (f1.cutpoints.length > 0) {
        trace (""patchCutFold: cutpoints left over in f1"");
    }
}

function addCutFold (v, v1, f, f1)
{
    var ff = new Fold (v.poly, v, v.next, f.level);
    // if (!v.fold || v.fold == f)
    v.fold = ff;
    // if (!v.next.fold || v.next.fold == f) 
    //   v.next.fold = ff;

    var ff1 = new Fold (v1.poly, v1, v1.next, f1.level);
    // if (!v1.fold || v1.fold == f1)
        v1.fold = ff1;
        // if (!v1.next.fold || v1.next.fold == f1)
        //  v1.next.fold = ff1;

    ff.twin = ff1;
    ff1.twin = ff;

    // twinned points must be co-located
    if (!peq(v, v1.next) || !peq(v1, v.next))
    {
        trace (""patchCutFold: fold point mismatch, f=("" +
               Math.round(v.x)+"",""+Math.round(v.y)+""),(""+
               Math.round(v.next.x)+"",""+Math.round(v.next.y)+"")""
               + "" f1=("" +
               Math.round(v1.x)+"",""+Math.round(v1.y)+""),(""+
               Math.round(v1.next.x)+"",""+Math.round(v1.next.y)+"")""
               );
        drawDiamond (v, cursor, 0xff0000);
        drawDiamond (v.next, cursor, 0xff0000);
        drawDiamond (v1, cursor, 0x0000ff);
        drawDiamond (v1.next, cursor, 0x0000ff);
        error = true;
    }
}

function clearPolyFlags (polys)
{
    for (i = 0; i<npolys; i++) {
        var p = polys[i];
        p.flipme = false;
        p.visited = false;
        p.is_anchor = false;
        p.flipped = false;
    }
}

function reflectMarkedPolys (polys, v1, v2, zlevels)
{
    // trace (""reflectMarkedPolys, z="" + zlevels);
    // dumpPolys (polys);
    npolys = polys.length;
	
    // fold all the marked polygons now.  These will be the ones on the flipme of the
    // fold or connected via earlier folds to one on the flipme.
    for (i = 0; i<npolys; i++) {
        var p = polys[i];
        if (p.flipme && !p.flipped) {
            reflectPoly (p, v1, v2, zlevels);
            // trace (""reflect poly "" + p.id);
            p.flipped = true;
        }
        //p.flipme = false;
        //p.visited = false;
        //p.is_anchor = false;
    }
}
 
/* reflectPoly
  * reflect the polygon p about the edge v1=>v1.next, set the z value and flip the
  * polygon's orientation.
  */
  
function reflectPoly (p, v1, v2, zlevels)
{
    var d2 = distanceSquared (v1, v2);
    if (d2 <= 0.01) return;
    var x21 = v2.x - v1.x;
    var y21 = v2.y - v1.y;
    var v = p.points;
    do {
        // loop over all the points in the polygon , compute the value of t
        // that describes the closest point on the edge (v1, v2) to the
        // point v, where the line is written v1 + t(v2-v1).  Then the new
        // reflected point v' is 2 (v1 + t(v2-v1)) - v
        //
        // however if the point lies on the reflection edge then skip it

        if (v == v1 || v == v2) {
            v = v.next;
            continue;
        }
        var t = ((v.x - v1.x) * x21 + (v.y - v1.y) * y21) / d2;
        v.x = 2 * (v1.x + t * (v2.x - v1.x)) - v.x;
        v.y = 2 * (v1.y + t * (v2.y - v1.y)) - v.y;
        v = v.next;
    } while (v != p.points);
    p.z = zlevels - p.z - 1;  // reflect the z-value about the midpoint
    p.faceup = !p.faceup;  // flip the poly over
}
 
/************************************************************************
 * basic polygon geometry and intersection calculations
 ************************************************************************/
 
function distanceSquared (u, v) {
    var dx = (u.x - v.x), dy = (u.y - v.y);
    return dx*dx + dy*dy;
}

/*
 * rhsTest
 *  checks which side of (x1,y1)->(x2, y2) (x,y) is on; returns 
 *  a boolean indicating whether it's on the rhs (or on the line itself).
 */
function rhsTest (x1, y1, x2, y2, x, y)
{
    var px = x - x1;
    var py = y - y1;
    var rx = x2 - x1;
    var ry = y2 - y1;
    return (px*ry - py*rx) <= 0 ? true : false;
}

/*
 * containsPoly
 *  returns a boolean indicating whether a point lies inside a polygon.  Determined by
 *  drawing a line from a point known to be outside the polygon to the point in question.
 *  If the number of intersections of the resulting line segment with the polygon is odd
 *  then the point lies inside the polygon, otherwise it's outside.
 */
 
function containsPoly (p, v)
{
    if (v.x < p.ul.x || v.x > p.br.x || v.y < p.ul.y || v.y > p.br.y)
        return false;
    var vout = new Point (-100, -100);
    var u = p.points;
    var intCount;
    do { 
        if (intersectEdges (vout, v, u, u.next, false)) {
            ++intCount;
        }
        u = u.next;
    } while (u != p.points)
  	return intCount % 2 == 1 ;
}

/*
 * intersectPoly
 *   Returns an array of intersections of a line segment and a polygon,
 *   sorted by distance from the start point of the line segment.
 *   The array contains structs with three elements; 
 *   pt: the point of intersection
 *   edge: the first point on the polygon of the edge on which the intersection lies.
 *   t: parameter values of the line equation (v1 + t *(v2-v1)); used to order the points
 *   If there is no intersection, an empty list is returned.
 */
function intersectPoly (p, v1, v2)
{
    var result = [];
    var param = { };            /* use for function return value since
                                   this language has no explicit references */
    var u = p.points;
    do { 
        var v = intersectEdges (v1, v2, u, u.next, true, param);
        if (v) {
            var i;
            for (i=0; i<result.length; i++) {
                if (result[i].t > param.t) {
                    break;
                }
            }
            result.splice (i, 0, {pt: v, edge: u, t : param.t});
        }
        u = u.next;
    } while (u != p.points);
    return result;
}

function intersectEdges (v1, v2, u1, u2, returnPoint, returnParam)
// test for intersection of line segment e with line segment formed by
// points[i],points[i+1]
//
// If returnPoint is true, the intersection point is returned,
// otherwise simply a Boolean indicating whether or not there is an 
// intersection
{
    // TBD: an overall speedup may result from this bounding box test
    if (! rectOverlap (u1, u2, v1, v2))
        return null;
    var x43 = u2.x - u1.x;
    var y43 = u2.y - u1.y;
    var x21 = v2.x - v1.x;
    var y21 = v2.y - v1.y;
    var denom = y43*x21 - x43*y21;
    if (Math.abs(denom) < 0.01) {
        return null;  // line segments are parallel
    }
    var x13 = v1.x - u1.x;
    var y13 = v1.y - u1.y;
    var t12 = (x43*y13 - y43*x13) / denom;
    if (returnParam) { returnParam.t = t12 };
    if (t12 > 1.0 || t12 < 0.0) {
        return null;  // intersection lies off of line segment e
    }
    var t34 = (x21*y13 - y21*x13) / denom;
    if (t34 > 1.0 || t34 < 0.0) {
        return null;  // intersection lies off of line segment p(i,j)
    }
    // found an intersection - return the point
    return returnPoint ? new Point (v1.x + t12 * x21, v1.y + t12 * y21)
        : true;
}

/**********************************************************************
 * little utilities
 **********************************************************************/

function polyStackComparison(v1, v2) {
    return v2.z-v1.z;
}

function findPrev (v)
{
    var u = v.poly.points;
    while (u.next != v) {
        u = u.next;
    }
    return u;
}

function setPointsPoly (p)
{
    var u = p.points;
    do {
        u.poly = p;
        u = u.next;
    } while (u != p.points) ;
}

function rectOverlap (u1, u2, v1, v2)
{
    if (v2.x > v1.x) { 
        if (u1.x > v2.x) {  
            if (u2.x > v2.x) { 
                return null; 
            }
        } else if (u1.x < v1.x) {
            if (u2.x < v1.x) {
                return null;
            }
        }
    } else {
        if (u1.x < v2.x) {
            if (u2.x < v2.x) {
                return null;
            }
        } else if (u1.x > v1.x) {
            if (u2.x > v1.x) {
                return null;
            }
        }
    }
    if (v2.y > v1.y) {
        if (u1.y > v2.y) {
            if (u2.y > v2.y) {
                return null;
            }
        } else if (u1.y < v1.y) {
            if (u2.y < v1.y) {
                return null;
            }
        }
    } else {
        if (u1.y < v2.y) {
            if (u2.y < v2.y) {
                return null;
            }
        } else if (u1.y > v1.y) {
            if (u2.y > v1.y) {
                return null;
            }
        }
    }
    return true;
}

function polysOverlap (p1, p2)
{
    if (p1.ul.x > p2.br.x ||
        p2.ul.x > p1.br.x ||
        p1.ul.y > p2.br.y ||
        p2.ul.y > p1.br.y) 
    {
        return false; 
    } 
    return true;
}

function getModelBounds (polys, descend)
{
    var left=1000, right=-1000, top=1000, bottom=-1000;
    for (var i =0; i<polys.length; i++) {
        var p = polys[i];
        if (descend)
            computeBoundingBox (p);
        if (p.ul.x < left) left = p.ul.x;
        if (p.br.x > right) right = p.br.x;
        if (p.ul.y < top) top = p.ul.y;
        if (p.br.y > bottom) bottom = p.br.y;
    }
    canvas.bounds = { left: left, top: top, bottom: bottom, right: right };
}

function computeBoundingBox (p)
{
    var left=1000, right=-1000, top=1000, bottom=-1000;
    var u = p.points;
    do {
        if (u.x < left) left = u.x;
        if (u.x > right) right = u.x;
        if (u.y > bottom) bottom = u.y;
        if (u.y < top) top = u.y;
        u = u.next;
    } while (u != p.points);
    if (p.ul) {
        p.ul.x = left;
        p.ul.y = top;
        p.br.x = right;
        p.br.y = bottom;
    } else {
        p.ul = new Point (left, top);
        p.br = new Point (right, bottom);
    }
}

/*
function dumpPolys (polys)
{
    for (var i =0; i<polys.length; i++) {
        dumpPoly (polys[i]);
    }
}

function dumpPoly (p)
{
    trace (""poly "" + p.id + "", flipme="" + p.flipme + "", visited="" + 
           p.visited + "", new="" + p.is_anchor + "", faceup="" + 
           p.faceup + "",z="" + p.z);
    var u = p.points;
    var txt = """";
    do {
        txt += ""     "" + Math.round(u.x) + "","" + Math.round(u.y);
        if (u.poly) txt += "" p"" + u.poly.id;
        if (u.fold) {
            txt += "" twin "" + u.fold.twin.v1.poly.id;
        }
        trace (txt); txt = """";
        if (u.fold) {
            if (peq(u.fold.v1, u)) {
                if (!peq (u.fold.v2, u.next)) {
                    trace (""  ERROR fold.v2 ("" + Math.round(u.fold.v2.x) +
                           "","" + Math.round(u.fold.v2.y) +
                           "")doesn't match u.next"");
                }
            } else if (!peq (u.fold.v2, u)) {
                trace (""  ERROR neither fold endpoint matches this point"");
            }
        }
        if (u.poly && u.poly.id != p.id) {
            trace (""  ERROR point poly id mismatch"");
        }
        u = u.next;
    } while (u != p.points);
}

function dumpPolyBrief (p)
{
    var u = p.points;
    var txt = ""poly: "";
    do {
        txt += ""("" + u.x + "","" + u.y + "")"";
        u = u.next;
    } while (u != p.points);
    trace (txt);
}

function checkModel(polys)
{
    for (var i = 0; i<polys.length; i++) {
        var pcount = 0;
        do {
            if (u.fold) {
                if (peq(u.fold.v1, u)) {
                    if (!peq (u.fold.v2, u.next)) {
                        trace (""  ERROR fold.v2 ("" + Math.round(u.fold.v2.x) +
                               "","" + Math.round(u.fold.v2.y) +
                               "")doesn't match u.next"");
                    }
                } else if (!peq (u.fold.v2, u)) {
                    trace (""  ERROR neither fold endpoint matches this point"");
                }
                if (u.fold.v1 != u) {
                    trace (""u.fold.v1 != u"");
                }
                if (u.fold.v2 != u.next) {
                    trace (""u.fold.v2 != u.next"");
                }
                if (u.fold.twin.twin != u.fold) {
                    trace (""u.fold.twin.twin != u.fold"");
                }
                if (! u.fold.twin.v1.poly.points) {
                    trace (""u.fold.twin.v1.poly.points is null"");
                }
                if (!peq (u.fold.v1, u.fold.twin.v2) ||
                    !peq (u.fold.v2, u.fold.twin.v1))
                {
                    trace (""  ERROR fold.twin mismatch  "");
                    drawDiamond (u.fold.v1, cursor, 0x0000ff);
                    drawDiamond (u.fold.v2, cursor, 0x0000ff);
                    drawDiamond (u.fold.twin.v1, cursor, 0xff0000);
                    drawDiamond (u.fold.twin.v2, cursor, 0xff0000);
                }
                if (u.fold.twin == u.fold || 
                    u.fold.twin.v1.poly == u.v1.poly)
                {
                    trace (""   ERROR fold is its own twin?"");
                    drawDiamond (u.fold.v1, cursor, 0x0000ff);
                    drawDiamond (u.fold.v2, cursor, 0x0000ff);
                }
            }
            if (u.poly && u.poly.id != p.id) {
                trace (""  ERROR point poly id mismatch"");
            }
            u = u.next;
            if (++pcount > 100) {
                trace (""WARNING: poly has > 100 points? possible inf. loop detected"");
                break;
            }
        } while (u != p.points);
    }
}
*/

/**********************************************************************
 * data structure functions; constructors, copiers, etc.
 **********************************************************************/

function Point(x, y, v) {
    this.x = x;
    this.y = y;
    this.next = v;
    return this;
    // this.poly = p;
}

function copyPoint (v) {
    var u = new Point (v.x, v.y);
    return u;
}

function peq (v, v1)
{
    return (Math.abs (v.x-v1.x) < 0.0001 &&
            Math.abs (v.y-v1.y) < 0.0001);
}

function deletePoint (v) {
    if (v.fold && v == v.fold.v1) {
        delete v.fold;
    }
    delete v;
}

function Poly() {
    this.points = null;
    this.z = 0;
    this.faceup = true;
    this.fgcolor = 0xdddddd;
	
    // These three flags are used to keep track of which polygons are to be
    // flipped when folding - we might combine them into a bit field...
    this.flipme = false;
    this.visited = false;
    this.is_anchor = false;
	
    this.id = canvas.next_poly_id++;
    return this;
}

function copyPoly (p) {
    var new_poly = new Poly ();
    new_poly.z = p.z;
    new_poly.faceup = p.faceup;
    new_poly.fgcolor = colors[new_poly.id % colors.length];
    return new_poly;
}

function deletePoly (p) {
    var v = p.points;
    var u = v.next;
    v.next = null;
    while (u) {
        var v = u.next;
        deletePoint (u);
        u = v;
    } 
    delete p;
}

function Fold (p, v1, v2, level) {
    this.v1 = v1;
    this.v2 = v2;
    this.level = level;
    this.twin = null;
    return this;
}
",12544,False,2108.3912666370243,median
"////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You 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 mx.controls
{
COMPILE::JS
{
	import goog.events;
	import org.apache.royale.core.WrappedHTMLElement;
	import org.apache.royale.html.util.addElementToWrapper;
}
import mx.controls.listClasses.BaseListData;
import mx.core.ITextInput;
import mx.core.UIComponent;
import mx.events.FlexEvent;

import org.apache.royale.core.ITextModel;
import org.apache.royale.events.Event;
import org.apache.royale.html.accessories.PasswordInputBead;
import org.apache.royale.html.beads.DisableBead;

COMPILE::SWF {
	import org.apache.royale.html.beads.TextInputView;
}

/*
import mx.managers.IFocusManager;
import mx.managers.IFocusManagerComponent;
import mx.managers.ISystemManager;
import mx.managers.SystemManager;
import mx.styles.ISimpleStyleClient;

use namespace mx_internal;
*/

//--------------------------------------
//  Events
//--------------------------------------

/**
 *  Dispatched when text in the TextInput control changes
 *  through user input.
 *  This event does not occur if you use data binding or
 *  ActionScript code to change the text.
 *
 *  <p>Even though the default value of the <code>Event.bubbles</code> property
 *  is <code>true</code>, this control dispatches the event with
 *  the <code>Event.bubbles</code> property set to <code>false</code>.</p>
 *
 *  @eventType flash.events.Event.CHANGE
 *
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Event(name=""change"", type=""flash.events.Event"")]

/**
 *  Dispatched when the <code>data</code> property changes.
 *
 *  <p>When you use a component as an item renderer,
 *  the <code>data</code> property contains the data to display.
 *  You can listen for this event and update the component
 *  when the <code>data</code> property changes.</p>
 *
 *  @eventType mx.events.FlexEvent.DATA_CHANGE
 *
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Event(name=""dataChange"", type=""mx.events.FlexEvent"")]

/**
 *  Dispatched when the user presses the Enter key.
 *
 *  @eventType mx.events.FlexEvent.ENTER
 *
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Event(name=""enter"", type=""mx.events.FlexEvent"")]

/**
 *  Dispatched when the user types, deletes, or pastes text into the control.
 *  No event is dispatched when the user presses the Delete key, or Backspace key.
 *
 *  <p>Even though the default value of the <code>TextEvent.bubbles</code> property
 *  is <code>true</code>, this control dispatches the event with
 *  the <code>TextEvent.bubbles</code> property set to <code>false</code>.</p>
 *
 *  @eventType flash.events.TextEvent.TEXT_INPUT
 *
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Event(name=""textInput"", type=""flash.events.TextEvent"")]


//--------------------------------------
//  Other metadata
//--------------------------------------

[DefaultBindingProperty(source=""text"", destination=""text"")]

[DefaultTriggerEvent(""change"")]


/**
 *  The TextInput control is a single-line text field
 *  that is optionally editable.
 *  All text in this control must use the same styling
 *  unless it is HTML text.
 *  The TextInput control supports the HTML rendering
 *  capabilities of Flash Player and AIR.
 *
 *  <p>TextInput controls do not include a label, although you
 *  can add one by using a Label control or by nesting the
 *  TextInput control in a FormItem control in a Form container.
 *  When used in a FormItem control, a TextInput control
 *  indicates whether a value is required.
 *  TextInput controls have a number of states, including filled,
 *  selected, disabled, and error.
 *  TextInput controls support formatting, validation, and keyboard
 *  equivalents; they also dispatch change and enter events.</p>
 *
 *  <p>If you disable a TextInput control, it displays its contents
 *  in the color specified by the <code>disabledColor</code>
 *  style.
 *  To disallow editing the text, you set the <code>editable</code>
 *  property to <code>false</code>.
 *  To conceal the input text by displaying asterisks instead of the
 *  characters entered, you set the <code>displayAsPassword</code> property
 *  to <code>true</code>.</p>
 *
 *  <p>The TextInput control is used as a subcomponent in several other controls,
 *  such as the RichTextEditor, NumericStepper, and ComboBox controls. As a result,
 *  if you assign style properties to a TextInput control by using a CSS type selector,
 *  Flex applies those styles to the TextInput when it appears in the other controls
 *  unless you explicitly override them.</p>
 *
 *  <p>The TextInput control has the following default sizing characteristics:</p>
 *     <table class=""innertable"">
 *        <tr>
 *           <th>Characteristic</th>
 *           <th>Description</th>
 *        </tr>
 *        <tr>
 *           <td>Default size</td>
 *           <td>The size of the text with a default minimum size of 22 pixels high and 160 pixels wide</td>
 *        </tr>
 *        <tr>
 *           <td>Minimum size</td>
 *           <td>0 pixels</td>
 *        </tr>
 *        <tr>
 *           <td>Maximum size</td>
 *           <td>10000 by 10000 pixels</td>
 *        </tr>
 *     </table>
 *
 *  @mxml
 *
 *  <p>The <code>&lt;mx:TextInput&gt;</code> tag inherits the attributes
 *  of its superclass and adds the following attributes:</p>
 *
 *  <pre>
 *  &lt;mx:TextInput
 *    <b>Properties</b>
 *    condenseWhite=""false|true""
 *    data=""undefined""
 *    displayAsPassword=""false|true""
 *    editable=""true|false""
 *    horizontalScrollPosition=""0""
 *    htmlText=""""
 *    imeMode=""null""
 *    length=""0""
 *    listData=""null""
 *    maxChars=""0""
 *    parentDrawsFocus=""false""
 *    restrict=""null""
 *    selectionBeginIndex=""0""
 *    selectionEndIndex=""0""
 *    text=""""
 *    textHeight=""0""
 *    textWidth=""0""
 *    &nbsp;
 *    <b>Styles</b>
 *    backgroundAlpha=""1.0""
 *    backgroundColor=""undefined""
 *    backgroundImage=""undefined""
 *    backgroundSize=""auto""
 *    borderColor=""0xAAB3B3""
 *    borderSides=""left top right bottom""
 *    borderSkin=""mx.skins.halo.HaloBorder""
 *    borderStyle=""inset""
 *    borderThickness=""1""
 *    color=""0x0B333C""
 *    cornerRadius=""0""
 *    disabledColor=""0xAAB3B3""
 *    dropShadowColor=""0x000000""
 *    dropShadowEnabled=""false""
 *    focusAlpha=""0.5""
 *    focusRoundedCorners""tl tr bl br""
 *    fontAntiAliasType=""advanced|normal""
 *    fontFamily=""Verdana""
 *    fontGridFitType=""pixel|none|subpixel""
 *    fontSharpness=""0""
 *    fontSize=""10""
 *    fontStyle=""normal|italic""
 *    fontThickness=""0""
 *    fontWeight=""normal|bold""
 *    paddingLeft=""0""
 *    paddingRight=""0""
 *    shadowDirection=""center""
 *    shadowDistance=""2""
 *    textAlign=""left|right|center""
 *    textDecoration=""none|underline""
 *    textIndent=""0""
 *    &nbsp;
 *    <b>Events</b>
 *    change=""<i>No default</i>""
 *    dataChange=""<i>No default</i>""
 *    enter=""<i>No default</i>""
 *    textInput=""<i>No default</i>""
 *  /&gt;
 *  </pre>
 *
 *  @includeExample examples/TextInputExample.mxml
 *
 *  @see mx.controls.Label
 *  @see mx.controls.Text
 *  @see mx.controls.TextArea
 *  @see mx.controls.RichTextEditor
 *  @see mx.controls.textClasses.TextRange
 *
 *  @helpid 3188
 *  @tiptext TextInput is a single-line, editable text field.
 *
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
public class TextInput extends UIComponent implements ITextInput
{
    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------

    /**
     *  Constructor.
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function TextInput()
    {
        super();
        typeNames = ""TextInput"";
		
		COMPILE::SWF
		{
			model.addEventListener(""textChange"", textChangeHandler);
		}
    }

    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     *  Flag that will block default data/listData behavior.
     */
    private var textSet:Boolean;

    /**
     *  @private
     */
    private var selectionChanged:Boolean = false;

    /**
     *  @private
     */
    private var errorCaught:Boolean = false;

    //--------------------------------------------------------------------------
    //
    //  Overridden properties
    //
    //--------------------------------------------------------------------------


    //----------------------------------
    //  enabled
    //----------------------------------

    /**
     *  @private
     */
    private var enabledChanged:Boolean = false;
	
	private var _disableBead:DisableBead;

    [Inspectable(category=""General"", enumeration=""true,false"", defaultValue=""true"")]

    /**
     *  @private
     *  Disable TextField when we're disabled.
     */
    override public function set enabled(value:Boolean):void
    {
        if (value == enabled)
            return;

        super.enabled = value;
//        enabledChanged = true;
//
//        invalidateProperties();
//
//         if (border && border is IInvalidating)
//             IInvalidating(border).invalidateDisplayList();
		
		if (_disableBead == null) {
			_disableBead = new DisableBead();
			addBead(_disableBead);
		}
		
		_disableBead.disabled = !value;
		
		COMPILE::SWF {
			var textView:TextInputView = view as TextInputView;
			textView.textField.mouseEnabled = super.enabled;
		}
    }

    //----------------------------------
    //  tabIndex
    //----------------------------------

    /**
     *  @private
     *  Storage for the tabIndex property.
     */
    private var _tabIndex:int = -1;

    /**
     *  @private
     */
    private var tabIndexChanged:Boolean = false;

    /**
     *  @private
     *  Tab order in which the control receives the focus when navigating
     *  with the Tab key.
     *
     *  @default -1
     *  @tiptext tabIndex of the component
     *  @helpid 3198
     */
//     override public function get tabIndex():int
//     {
//         return _tabIndex;
//     }

    /**
     *  @private
     */
//     override public function set tabIndex(value:int):void
//     {
//         if (value == _tabIndex)
//             return;
//
//         _tabIndex = value;
//         tabIndexChanged = true;
//
//         invalidateProperties();
//     }

    //--------------------------------------------------------------------------
    //
    //  Properties
    //
    //--------------------------------------------------------------------------
    
    //----------------------------------
    //  borderVisible
    //----------------------------------
	
    public function get borderVisible():Boolean
    {
        return true;
    }
	
    public function set borderVisible(value:Boolean) :void
    {
        
    }
    
    //----------------------------------
    //  data
    //----------------------------------

    /**
     *  @private
     *  Storage for the data property.
     */
    private var _data:Object;

    [Bindable(""dataChange"")]
    [Inspectable(environment=""none"")]

    /**
     *  Lets you pass a value to the component
     *  when you use it in an item renderer or item editor.
     *  You typically use data binding to bind a field of the <code>data</code>
     *  property to a property of this component.
     *
     *  <p>When you use the control as a drop-in item renderer or drop-in
     *  item editor, Flex automatically writes the current value of the item
     *  to the <code>text</code> property of this control.</p>
     *
     *  <p>You do not set this property in MXML.</p>
     *
     *  @default null
     *  @see mx.core.IDataRenderer
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get data():Object
    {
        return _data;
    }

    /**
     *  @private
     */
    public function set data(value:Object):void
    {
        var newText:*;

        _data = value;

        if (_listData)
        {
            newText = _listData.label;
        }
        else if (_data != null)
        {
            if (_data is String)
                newText = String(_data);
            else
                newText = _data.toString();
        }

        if (newText !== undefined && !textSet)
        {
            text = newText;
            textSet = false;
            // changing text should trigger the TextInput's view bead to change the display.
            //textField.setSelection(0, 0);
        }

        dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
    }

    //----------------------------------
    //  displayAsPassword
    //----------------------------------

    /**
     *  @private
     *  Storage for the displayAsPassword property.
     */
    private var _displayAsPassword:Boolean = false;

    /**
     *  @private
     */
	private var _passwordBead:PasswordInputBead;
    private var displayAsPasswordChanged:Boolean = false;

    [Bindable(""displayAsPasswordChanged"")]
    [Inspectable(category=""General"", defaultValue=""false"")]

    /**
     *  Indicates whether this control is used for entering passwords.
     *  If <code>true</code>, the field does not display entered text,
     *  instead, each text character entered into the control
     *  appears as the  character ""&#42;"".
     *
     *  @default false
     *  @tiptext Specifies whether to display '*'
     *  instead of the actual characters
     *  @helpid 3197
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get displayAsPassword():Boolean
    {
        return _displayAsPassword;
    }

    /**
     *  @private
     */
    public function set displayAsPassword(value:Boolean):void
    {
        if (value == _displayAsPassword)
            return;

        _displayAsPassword = value;
//        displayAsPasswordChanged = true;
//
//        invalidateProperties();
//        invalidateSize();
//        invalidateDisplayList();;
		
		if (_displayAsPassword && _passwordBead == null) {
			_passwordBead = new PasswordInputBead();
			addBead(_passwordBead);
		}
		else if (!_displayAsPassword && _passwordBead != null) {
			removeBead(_passwordBead);
			_passwordBead = null;
		}

        dispatchEvent(new Event(""displayAsPasswordChanged""));
    }

    //----------------------------------
    //  editable
    //----------------------------------

    /**
     *  @private
     *  Storage for the editable property.
     */
    private var _editable:Boolean = true;

    /**
     *  @private
     */
    private var editableChanged:Boolean = false;

    [Bindable(""editableChanged"")]
    [Inspectable(category=""General"", defaultValue=""true"")]

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get editable():Boolean
    {
        return _editable;
    }

    /**
     *  @private
     */
    public function set editable(value:Boolean):void
    {
        if (value == _editable)
            return;

        _editable = value;
        editableChanged = true;

        invalidateProperties();

        dispatchEvent(new Event(""editableChanged""));
    }

    //----------------------------------
    //  horizontalScrollPosition
    //----------------------------------

    /**
     *  @private
     *  Used to store the init time value if any.
     */
    private var _horizontalScrollPosition:Number = 0;

    /**
     *  @private
     */
    private var horizontalScrollPositionChanged:Boolean = false;

    [Bindable(""horizontalScrollPositionChanged"")]
    [Inspectable(defaultValue=""0"")]


    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get horizontalScrollPosition():Number
    {
        return _horizontalScrollPosition;
    }

    /**
     *  @private
     */
    public function set horizontalScrollPosition(value:Number):void
    {
        if (value == _horizontalScrollPosition)
            return;

        _horizontalScrollPosition = value;
        horizontalScrollPositionChanged = true;

        invalidateProperties();

        dispatchEvent(new Event(""horizontalScrollPositionChanged""));
    }

    //----------------------------------
    //  htmlText
    //----------------------------------

    /**
     *  @private
     *  Storage for the htmlText property.
     *  In addition to being set in the htmlText setter,
     *  it is automatically updated at two other times.
     *  1. When the 'text' or 'htmlText' is pushed down into
     *  the textField in commitProperties(), this causes
     *  the textField to update its own 'htmlText'.
     *  Therefore in commitProperties() we reset this storage var
     *  to be in sync with the textField.
     *  2. When the TextFormat of the textField changes
     *  because a CSS style has changed (see validateNow()
     *  in UITextField), the textField also updates its own 'htmlText'.
     *  Therefore in textField_textFieldStyleChangeHandler()
     */
    private var _htmlText:String = """";

    /**
     *  @private
     */
    private var htmlTextChanged:Boolean = false;

    /**
     *  @private
     *  The last value of htmlText that was set.
     *  We have to keep track of this because when you set the htmlText
     *  of a TextField and read it back, you don't get what you set.
     *  In general it will have additional HTML markup corresponding
     *  to the defaultTextFormat set from the CSS styles.
     *  If this var is null, it means that 'text' rather than 'htmlText'
     *  was last set.
     */
    private var explicitHTMLText:String = null;

    [Bindable(""htmlTextChanged"")]
    [CollapseWhiteSpace]
    [Inspectable(category=""General"", defaultValue="""")]
    [NonCommittingChangeEvent(""change"")]

   /**
     *  Specifies the text displayed by the TextInput control, including HTML markup that
     *  expresses the styles of that text.
     *  When you specify HTML text in this property, you can use the subset of HTML
     *  tags that is supported by the Flash TextField control.
     *
     *  <p> When you set this property, the HTML markup is applied
     *  after the CSS styles for the TextInput instance are applied.
     *  When you get this property, the HTML markup includes
     *  the CSS styles.</p>
     *
     *  <p>For example, if you set this to be a string such as,
     *  <code>""This is an example of &lt;b&gt;bold&lt;/b&gt; markup""</code>,
     *  the text ""This is an example of <b>bold</b> markup"" appears
     *  in the TextInput with whatever CSS styles normally apply.
     *  Also, the word ""bold"" appears in boldface font because of the
     *  <code>&lt;b&gt;</code> markup.</p>
     *
     *  <p>HTML markup uses characters such as &lt; and &gt;,
     *  which have special meaning in XML (and therefore in MXML). So,
     *  code such as the following does not compile:</p>
     *
     *  <pre>
     *  &lt;mx:TextInput htmlText=""This is an example of &lt;b&gt;bold&lt;/b&gt; markup""/&gt;
     *  </pre>
     *
     *  <p>There are three ways around this problem.</p>
     *
     *  <ul>
     *
     *  <li>
     *
     *  <p>Set the <code>htmlText</code> property in an ActionScript method called as
     *  an <code>initialize</code> handler:</p>
     *
     *  <pre>
     *  &lt;mx:TextInput id=""myTextInput"" initialize=""myTextInput_initialize()""/&gt;
     *  </pre>
     *
     *  <p>where the <code>myTextInput_initialize</code> method is in a script CDATA section:</p>
     *
     *  <pre>
     *  &lt;fx:Script&gt;
     *  &lt;![CDATA[
     *  private function myTextInput_initialize():void {
     *      myTextInput.htmlText = ""This is an example of &lt;b&gt;bold&lt;/b&gt; markup"";
     *  }
     *  ]]&gt;
     *  &lt;/fx:Script&gt;
     *
     *  </pre>
     *
     *  <p>This is the simplest approach because the HTML markup
     *  remains easily readable.
     *  Notice that you must assign an <code>id</code> to the TextInput
     *  so you can refer to it in the <code>initialize</code>
     *  handler.</p>
     *
     *  </li>
     *
     *  <li>
     *
     *  <p>Specify the <code>htmlText</code> property by using a child tag
     *  with a CDATA section. A CDATA section in XML contains character data
     *  where characters like &lt; and &gt; aren't given a special meaning.</p>
     *
     *  <pre>
     *  &lt;mx:TextInput&gt;
     *      &lt;mx:htmlText&gt;&lt;![CDATA[This is an example of &lt;b&gt;bold&lt;/b&gt; markup]]&gt;&lt;/mx:htmlText&gt;
     *  &lt;mx:TextInput/&gt;
     *  </pre>
     *
     *  <p>You must write the <code>htmlText</code> property as a child tag
     *  rather than as an attribute on the <code>&lt;mx:TextInput&gt;</code> tag
     *  because XML doesn't allow CDATA for the value of an attribute.
     *  Notice that the markup is readable, but the CDATA section makes
     *  this approach more complicated.</p>
     *
     *  </li>
     *
     *  <li>
     *
     *  <p>Use an <code>hmtlText</code> attribute where any occurences
     *  of the HTML markup characters &lt; and &gt; in the attribute value
     *  are written instead as the XML ""entities"" <code>&amp;lt;</code>
     *  and <code>&amp;gt;</code>:</p>
     *
     *  <pre>
     *  &lt;mx:TextInput htmlText=""This is an example of &amp;lt;b&amp;gt;bold&amp;lt;/b&amp;gt; markup""/&amp;gt;
     *  </pre>
     *
     *  Adobe does not recommend this approach because the HTML markup becomes
     *  nearly impossible to read.
     *
     *  </li>
     *
     *  </ul>
     *
     *  <p>If the <code>condenseWhite</code> property is <code>true</code>
     *  when you set the <code>htmlText</code> property, multiple
     *  white-space characters are condensed, as in HTML-based browsers;
     *  for example, three consecutive spaces are displayed
     *  as a single space.
     *  The default value for <code>condenseWhite</code> is
     *  <code>false</code>, so you must set <code>condenseWhite</code>
     *  to <code>true</code> to collapse the white space.</p>
     *
     *  <p>If you read back the <code>htmlText</code> property quickly
     *  after setting it, you get the same string that you set.
     *  However, after the LayoutManager runs, the value changes
     *  to include additional markup that includes the CSS styles.</p>
     *
     *  <p>Setting the <code>htmlText</code> property affects the <code>text</code>
     *  property in several ways.
     *  If you read the <code>text</code> property quickly after setting
     *  the <code>htmlText</code> property, you get <code>null</code>,
     *  which indicates that the <code>text</code> corresponding to the new
     *  <code>htmlText</code> has not yet been determined.
     *  However, after the LayoutManager runs, the <code>text</code> property
     *  value changes to the <code>htmlText</code> string with all the
     *  HTML markup removed; that is,
     *  the value is the characters that the TextInput actually displays.</p>
     *
     *  <p>Conversely, if you set the <code>text</code> property,
     *  any previously set <code>htmlText</code> is irrelevant.
     *  If you read the <code>htmlText</code> property quickly after setting
     *  the <code>text</code> property, you get <code>null</code>,
     *  which indicates that the <code>htmlText</code> that corresponds to the new
     *  <code>text</code> has not yet been determined.
     *  However, after the LayoutManager runs, the <code>htmlText</code> property
     *  value changes to the new text plus the HTML markup for the CSS styles.</p>
     *
     *  <p>To make the LayoutManager run immediately, you can call the
     *  <code>validateNow()</code> method on the TextInput.
     *  For example, you could set some <code>htmlText</code>,
     *  call the <code>validateNow()</code> method, and immediately
     *  obtain the corresponding <code>text</code> that doesn't have
     *  the HTML markup.</p>
     *
     *  <p>If you set both <code>text</code> and <code>htmlText</code> properties
     *  in ActionScript, whichever is set last takes effect.
     *  Do not set both in MXML, because MXML does not guarantee that
     *  the properties of an instance get set in any particular order.</p>
     *
     *  <p>Setting either <code>text</code> or <code>htmlText</code> property
     *  inside a loop is a fast operation, because the underlying TextField
     *  that actually renders the text is not updated until
     *  the LayoutManager runs.</p>
     *
     *  <p>If you try to set this property to <code>null</code>,
     *  it is set, instead, to the empty string.
     *  If the property temporarily has the value <code>null</code>,
     *  it indicates that the <code>text</code> has been recently set
     *  and the corresponding <code>htmlText</code>
     *  has not yet been determined.</p>
     *
     *  @default """"
     *
     *  @see flash.text.TextField#htmlText
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get htmlText():String
    {
		COMPILE::SWF
		{
			return ITextModel(model).html;
		}
		COMPILE::JS
		{
			return (element as HTMLInputElement).value;
		}
    }

    /**
     *  @private
     */
    public function set htmlText(value:String):void
    {
		COMPILE::SWF
		{
			ITextModel(model).html = value;
		}
		COMPILE::JS
		{
			(element as HTMLInputElement).value = value;
			dispatchEvent(new Event('textChange'));
		}
    }

    //----------------------------------
    //  isHTML
    //----------------------------------

    /**
     *  @private
     */
    private function get isHTML():Boolean
    {
        return explicitHTMLText != null;
    }

    //----------------------------------
    //  length
    //----------------------------------

    /**
     *  The number of characters of text displayed in the TextArea.
     *
     *  @default 0
     *  @tiptext The number of characters in the TextInput.
     *  @helpid 3192
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get length():int
    {
        return text != null ? text.length : -1;
    }

    //----------------------------------
    //  listData
    //----------------------------------

    private var _listData:BaseListData;

    [Bindable(""dataChange"")]
    [Inspectable(environment=""none"")]

    /**
     *  When a component is used as a drop-in item renderer or drop-in
     *  item editor, Flex initializes the <code>listData</code> property
     *  of the component with the appropriate data from the list control.
     *  The component can then use the <code>listData</code> property
     *  to initialize the <code>data</code> property of the drop-in
     *  item renderer or drop-in item editor.
     *
     *  <p>You do not set this property in MXML or ActionScript;
     *  Flex sets it when the component is used as a drop-in item renderer
     *  or drop-in item editor.</p>
     *
     *  @default null
     *  @see mx.controls.listClasses.IDropInListItemRenderer
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get listData():BaseListData
    {
        return _listData;
    }

    /**
     *  @private
     */
    public function set listData(value:BaseListData):void
    {
        _listData = value;
    }

    //----------------------------------
    //  maxChars
    //----------------------------------

    /**
     *  @private
     *  Storage for the maxChars property.
     */
    private var _maxChars:int = 0;

    /**
     *  @private
     */
    private var maxCharsChanged:Boolean = false;

    [Bindable(""maxCharsChanged"")]
    [Inspectable(category=""General"", defaultValue=""0"")]

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get maxChars():int
    {
        return _maxChars;
    }

    /**
     *  @private
     */
    public function set maxChars(value:int):void
    {
        if (value == _maxChars)
            return;

        _maxChars = value;
        maxCharsChanged = true;

        invalidateProperties();

        dispatchEvent(new Event(""maxCharsChanged""));
    }

    //----------------------------------
    //  maxHorizontalScrollPosition
    //----------------------------------

    /**
     *  @private
     *  Maximum value of <code>horizontalScrollPosition</code>.
     *
     *  <p>The default value is 0, which means that horizontal scrolling is not
     *  required.</p>
     *
     *  <p>The value of the <code>maxHorizontalScrollPosition</code> property is
     *  computed from the data and size of component, and must not be set by
     *  the application code.</p>
     */
    public function get maxHorizontalScrollPosition():Number
    {
        return 0;//textField ? textField.maxScrollH : 0;
    }

    //----------------------------------
    //  parentDrawsFocus
    //----------------------------------

    /**
     *  @private
     *  Storage for the parentDrawsFocus property.
     */
    private var _parentDrawsFocus:Boolean = false;

    [Inspectable(category=""General"", enumeration=""true,false"", defaultValue=""false"")]

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get parentDrawsFocus():Boolean
    {
        return _parentDrawsFocus;
    }

    /**
     *  @private
     */
    public function set parentDrawsFocus(value:Boolean):void
    {
        _parentDrawsFocus = value;
    }

    //----------------------------------
    //  restrict
    //----------------------------------

    /**
     *  @private
     *  Storage for the restrict property.
     */
    private var _restrict:String;

    /**
     *  @private
     */
    private var restrictChanged:Boolean = false;

    [Bindable(""restrictChanged"")]
    [Inspectable(category=""General"")]

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get restrict():String
    {
        return _restrict;
    }

    /**
     *  @private
     */
    public function set restrict(value:String):void
    {
        if (value == _restrict)
            return;

        _restrict = value;
        restrictChanged = true;

        invalidateProperties();

        dispatchEvent(new Event(""restrictChanged""));
    }

    //----------------------------------
    //  selectable
    //----------------------------------

    /**
     *  @private
     *  Used to make TextInput function correctly in the components that use it
     *  as a subcomponent. ComboBox, at this point.
     */
    private var _selectable:Boolean = true;

    /**
     *  @private
     */
    private var selectableChanged:Boolean = false;

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectable():Boolean
    {
        return _selectable;
    }

    /**
     *  @private
     */
    public function set selectable(value:Boolean):void
    {
        if (_selectable == value)
            return;
        _selectable = value;
        selectableChanged = true;
        invalidateProperties();
    }
    //----------------------------------
    //  selectionBeginIndex
    //----------------------------------

    /**
     *  @private
     *  Storage for the selectionBeginIndex property.
     */
    private var _selectionBeginIndex:int = 0;

    [Inspectable(defaultValue=""0"")]

    /**
     *  The zero-based character index value of the first character
     *  in the current selection.
     *  For example, the first character is 0, the second character is 1,
     *  and so on.
     *  When the control gets the focus, the selection is visible if the
     *  <code>selectionBeginIndex</code> and <code>selectionEndIndex</code>
     *  properties are both set.
     *
     *  @default 0
     *
     *  @tiptext The zero-based index value of the first character
     *  in the selection.
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectionBeginIndex():int
    {
        return _selectionBeginIndex;
    }

    /**
     *  @private
     */
    public function set selectionBeginIndex(value:int):void
    {
        _selectionBeginIndex = value;
    }

    //----------------------------------
    //  selectionEndIndex
    //----------------------------------

    /**
     *  @private
     *  Storage for the selectionEndIndex property.
     */
    private var _selectionEndIndex:int = 0;

    [Inspectable(defaultValue=""0"")]

    /**
     *  The zero-based index of the position <i>after</i> the last character
     *  in the current selection (equivalent to the one-based index of the last
     *  character).
     *  If the last character in the selection, for example, is the fifth
     *  character, this property has the value 5.
     *  When the control gets the focus, the selection is visible if the
     *  <code>selectionBeginIndex</code> and <code>selectionEndIndex</code>
     *  properties are both set.
     *
     *  @default 0
     *
     *  @tiptext The zero-based index value of the last character
     *  in the selection.
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectionEndIndex():int
    {
        return _selectionEndIndex;
    }

    /**
     *  @private
     */
    public function set selectionEndIndex(value:int):void
    {
        _selectionEndIndex = value;
        selectionChanged = true;

        invalidateProperties();
    }

    //----------------------------------
    //  text
    //----------------------------------


    /**
     *  @private
     */
    private var textChanged:Boolean = false;

    //[Bindable(""textChanged"")]
    [Bindable(""change"")]
    [CollapseWhiteSpace]
    [Inspectable(category=""General"", defaultValue="""")]
    //[NonCommittingChangeEvent(""change"")]  Not sure what this did
    // since TextField sends change on every keystroke and other
    // code looked like it would dispatch a textChanged

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     *  @royaleignorecoercion HTMLInputElement
     */
    public function get text():String
    {
		COMPILE::SWF
		{
			return ITextModel(model).text;
		}
		COMPILE::JS
		{
			return (element as HTMLInputElement).value;
		}
    }

    /**
     *  @private
     */
    public function set text(value:String):void
    {
		COMPILE::SWF
		{
			inSetter = true;
			ITextModel(model).text = value;
			inSetter = false;
		}
		
		COMPILE::JS
		{
			(element as HTMLInputElement).value = value;
		}

        dispatchEvent(new Event('textChanged'));
        dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
    }

    //--------------------------------------------------------------------------
    //
    //  Overridden methods
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     *  Create child objects.
     */
    override protected function createChildren():void
    {
        super.createChildren();
    }

    /**
     *  @private
     */
    override protected function commitProperties():void
    {
        super.commitProperties();


//         if (hasFontContextChanged() && textField != null)
//         {
//             var childIndex:int = getChildIndex(DisplayObject(textField));
//             removeTextField();
//             createTextField(childIndex);
//
//             accessibilityPropertiesChanged = true;
//             condenseWhiteChanged = true;
//             displayAsPasswordChanged = true;
//             enabledChanged = true;
//             maxCharsChanged = true;
//             restrictChanged = true;
//             tabIndexChanged = true;
//             textChanged = true;
//             selectionChanged = true;
//             horizontalScrollPositionChanged = true;
//         }
//
//         if (accessibilityPropertiesChanged)
//         {
//             textField.accessibilityProperties = _accessibilityProperties;
//
//             accessibilityPropertiesChanged = false;
//         }
//
//         if (condenseWhiteChanged)
//         {
//             textField.condenseWhite = _condenseWhite;
//
//             condenseWhiteChanged = false;
//         }
//
//         if (displayAsPasswordChanged)
//         {
//             textField.displayAsPassword = _displayAsPassword;
//
//             displayAsPasswordChanged = false;
//         }
//
//         if (enabledChanged || editableChanged)
//         {
//             textField.type = enabled && _editable ?
//                              TextFieldType.INPUT :
//                              TextFieldType.DYNAMIC;
//
//             if (enabledChanged)
//             {
//                 if (textField.enabled != enabled)
//                     textField.enabled = enabled;
//
//                 enabledChanged = false;
//             }
//             selectableChanged = true;
//             editableChanged = false;
//         }
//
//         if (selectableChanged)
//         {
//             if (_editable)
//                 textField.selectable = enabled;
//             else
//                 textField.selectable = enabled && _selectable;
//             selectableChanged = false;
//         }
//
//         if (maxCharsChanged)
//         {
//             textField.maxChars = _maxChars;
//
//             maxCharsChanged = false;
//         }
//
//         if (restrictChanged)
//         {
//             textField.restrict = _restrict;
//
//             restrictChanged = false;
//         }
//
//         if (tabIndexChanged)
//         {
//             textField.tabIndex = _tabIndex;
//
//             tabIndexChanged = false;
//         }
//
//         if (textChanged || htmlTextChanged)
//         {
//             // If the 'text' and 'htmlText' properties have both changed,
//             // the last one set wins.
//             if (isHTML)
//                 textField.htmlText = explicitHTMLText;
//             else
//                 textField.text = _text;
//
//             textFieldChanged(false, true);
//
//             textChanged = false;
//             htmlTextChanged = false;
//         }
//
//         if (selectionChanged)
//         {
//             textField.setSelection(_selectionBeginIndex, _selectionEndIndex);
//
//             selectionChanged = false;
//         }
//
//         if (horizontalScrollPositionChanged)
//         {
//             textField.scrollH = _horizontalScrollPosition;
//
//             horizontalScrollPositionChanged = false;
//         }
    }

    /**
     *  @private
     */
    override protected function measure():void
    {
        super.measure();

        trace(""TextInput.measure not implemented"");

//         var bm:EdgeMetrics = border && border is IRectangularBorder ?
//                              IRectangularBorder(border).borderMetrics :
//                              EdgeMetrics.EMPTY;
//
//         var w:Number;
//         var h:Number;
//
//         // Start with a width of 160. This may change.
//         measuredWidth = DEFAULT_MEASURED_WIDTH;
//
//         if (maxChars)
//         {
//             // Use the width of ""W"" and multiply by the maxChars
//             measuredWidth = Math.min(measuredWidth,
//                 measureText(""W"").width * maxChars + bm.left + bm.right + 8);
//         }
//
//         if (!text || text == """")
//         {
//             w = DEFAULT_MEASURED_MIN_WIDTH;
//             h = measureText("" "").height +
//                 bm.top + bm.bottom + UITextField.TEXT_HEIGHT_PADDING;
//             h += getStyle(""paddingTop"") + getStyle(""paddingBottom"");
//         }
//         else
//         {
//             var lineMetrics:TextLineMetrics;
//             lineMetrics = measureText(text);
//
//             w = lineMetrics.width + bm.left + bm.right + 8;
//             h = lineMetrics.height + bm.top + bm.bottom + UITextField.TEXT_HEIGHT_PADDING;
//
//             w += getStyle(""paddingLeft"") + getStyle(""paddingRight"");
//             h += getStyle(""paddingTop"") + getStyle(""paddingBottom"");
//         }
//
//         measuredWidth = Math.max(w, measuredWidth);
//         measuredHeight = Math.max(h, DEFAULT_MEASURED_HEIGHT);
//
//         measuredMinWidth = DEFAULT_MEASURED_MIN_WIDTH;
//         measuredMinHeight = DEFAULT_MEASURED_MIN_HEIGHT;
    }

    /**
     *  @private
     *  Stretch the border and fit the TextField inside it.
     */
    override protected function updateDisplayList(unscaledWidth:Number,
                                                  unscaledHeight:Number):void
    {
        super.updateDisplayList(unscaledWidth, unscaledHeight);

        trace(""TextInput.updateDisplayList not implemented"");
//         var bm:EdgeMetrics;
//
//         if (border)
//         {
//             border.setActualSize(unscaledWidth, unscaledHeight);
//             bm = border is IRectangularBorder ?
//                     IRectangularBorder(border).borderMetrics : EdgeMetrics.EMPTY;
//         }
//         else
//         {
//             bm = EdgeMetrics.EMPTY;
//         }
//
//         var paddingLeft:Number = getStyle(""paddingLeft"");
//         var paddingRight:Number = getStyle(""paddingRight"");
//         var paddingTop:Number = getStyle(""paddingTop"");
//         var paddingBottom:Number = getStyle(""paddingBottom"");
//         var widthPad:Number = bm.left + bm.right;
//         var heightPad:Number = bm.top + bm.bottom + 1;
//
//         textField.x = bm.left;
//         textField.y = bm.top;
//
//         textField.x += paddingLeft;
//         textField.y += paddingTop;
//         widthPad += paddingLeft + paddingRight;
//         heightPad += paddingTop + paddingBottom;
//
//         textField.width = Math.max(0, unscaledWidth - widthPad);
//         textField.height = Math.max(0, unscaledHeight - heightPad);
    }

    /**
     *  @private
     *  Focus should always be on the internal TextField.
     */
    COMPILE::SWF
    override public function setFocus():void
    {
        var textView:TextInputView = view as TextInputView;
        textView.textField.stage.focus = textView.textField
    }

    /**
     *  @private
     */
    override public function styleChanged(styleProp:String):void
    {
    	trace(""TextInput.styleChanged not implemented"");
//         var allStyles:Boolean = (styleProp == null || styleProp == ""styleName"");
//
//         super.styleChanged(styleProp);
//
//         // Replace the borderSkin
//         if (allStyles || styleProp == ""borderSkin"")
//         {
//             if (border)
//             {
//                 removeChild(DisplayObject(border));
//                 border = null;
//                 createBorder();
//             }
//         }
    }
	
	//--------------------------------------------------------------------------
	//
	//  createElement
	//
	//--------------------------------------------------------------------------
	
	/**
	 * @royaleignorecoercion org.apache.royale.core.WrappedHTMLElement
	 */
	COMPILE::JS
	override protected function createElement():WrappedHTMLElement
	{
		addElementToWrapper(this,'input');
		element.setAttribute('type', 'text');
		
		//attach input handler to dispatch royale change event when user write in textinput
		//goog.events.listen(element, 'change', killChangeHandler);
		goog.events.listen(element, 'input', textChangeHandler);
		return element;
	}
	
	private var inSetter:Boolean;

	/**
	 *  dispatch change event in response to a textChange event
	 *
	 *  @langversion 3.0
     *  @playerversion Flash 10.2
     *  @playerversion AIR 2.6
     *  @productversion Royale 0.0
	 */
	public function textChangeHandler(event:Event):void
	{
        if (!inSetter)
            dispatchEvent(new Event(Event.CHANGE));
	}

    //--------------------------------------------------------------------------
    //
    //  Methods
    //
    //--------------------------------------------------------------------------


    /**
     *  Creates the border for this component.
     *  Normally the border is determined by the
     *  <code>borderStyle</code> and <code>borderSkin</code> styles.
     *  It must set the border property to the instance
     *  of the border.
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function createBorder():void
    {
    	trace(""TextInput.createBorder not implemented"");
//         if (!border)
//         {
//             var borderClass:Class = getStyle(""borderSkin"");
//
//             if (borderClass != null)
//             {
//                 border = new borderClass();
//
//                 if (border is ISimpleStyleClient)
//                     ISimpleStyleClient(border).styleName = this;
//
//                 // Add the border behind all the children.
//                 addChildAt(DisplayObject(border), 0);
//
//                 invalidateDisplayList();
//             }
//         }
    }

    /**
     *  Selects the text in the range specified by the parameters.
     *  If the control is not in focus, the selection highlight will not show
     *  until the control gains focus. Also, if the focus is gained by clicking
     *  on the control, any previous selection would be lost.
     *  If the two parameter values are the same,
     *  the new selection is an insertion point.
     *
     *  @param beginIndex The zero-based index of the first character in the
     *  selection; that is, the first character is 0, the second character
     *  is 1, and so on.
     *
     *  @param endIndex The zero-based index of the position <i>after</i>
     *  the last character in the selection (equivalent to the one-based
     *  index of the last character).
     *  If the parameter is 5, the last character in the selection, for
     *  example, is the fifth character.
     *  When the TextInput control gets the focus, the selection is visible
     *  if the <code>selectionBeginIndex</code> and <code>selectionEndIndex</code>
     *  properties are both set.
     *
     *  @tiptext Sets a new text selection.
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function setSelection(beginIndex:int, endIndex:int):void
    {
        _selectionBeginIndex = beginIndex;
        _selectionEndIndex = endIndex;
        selectionChanged = true;

        invalidateProperties();
    }

    /**
     *  @private
     *  Setting the 'htmlText' of textField changes its 'text',
     *  and vice versa, so afterwards doing so we call this method
     *  to update the storage vars for various properties.
     *  Afterwards, the TextInput's 'text', 'htmlText', 'textWidth',
     *  and 'textHeight' are all in sync with each other
     *  and are identical to the TextField's.
     */
    private function textFieldChanged(styleChangeOnly:Boolean,
                                      dispatchValueCommitEvent:Boolean):void
    {
    	trace(""TextInput.textFieldChanged not implemented"");
//         var changed1:Boolean;
//         var changed2:Boolean;
//
//         if (!styleChangeOnly)
//         {
//             changed1 = _text != textField.text;
//             _text = textField.text;
//         }
//
//         changed2 = _htmlText != textField.htmlText;
//         _htmlText = textField.htmlText;
//
//         // If the 'text' property changes, trigger bindings to it
//         // and conditionally dispatch a 'valueCommit' event.
//         if (changed1)
//         {
//             dispatchEvent(new Event(""textChanged""));
//
//             if (dispatchValueCommitEvent)
//                 dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
//         }
//         // If the 'htmlText' property changes, trigger bindings to it.
//         if (changed2)
//             dispatchEvent(new Event(""htmlTextChanged""));
//
//         _textWidth = textField.textWidth;
//         _textHeight = textField.textHeight;
    }

    //--------------------------------------------------------------------------
    //
    //  ITextInput Interface
    //
    //--------------------------------------------------------------------------

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectionActivePosition():int
    {
        return selectionEndIndex;
    }


    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectionAnchorPosition():int
    {
        return selectionBeginIndex;
    }

    /**
     *  Selects the text in the range specified by the parameters.  Unlike
     *  <code>setSelection</code> this is done immediately.
     *
     *  @param anchorIndex The zero-based character index specifying the beginning
     *  of the selection that stays fixed when the selection is extended.
     *
     *  @param activeIndex The zero-based character index specifying
     *  the end of the selection that moves when the selection is extended.
     *
     *  @langversion 3.0
     *  @playerversion Flash 10
     *  @playerversion AIR 1.5
     *  @productversion Flex 4
     */
    public function selectRange(anchorIndex:int, activeIndex:int):void
    {
    	trace(""TextInput.selectRange not implemented"");
        // Do it immediately.
//         textField.setSelection(anchorIndex, activeIndex);
    }

    //--------------------------------------------------------------------------
    //
    //  Overridden event handlers: UIComponent
    //
    //--------------------------------------------------------------------------

    //--------------------------------------------------------------------------
    //
    //  Event handlers
    //
    //--------------------------------------------------------------------------

}

}
",12476,True,2590.35944614014,median
"/*

  FlipMode.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  Preconditions:
  Uno with DOGS102 Shield
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


void setup(void) {
  u8g2.begin();
  u8g2.setFont(u8g2_font_6x10_tr);
}


void draw(const char *s)
{
  u8g2.firstPage();
  do {
    u8g2.drawStr(2,15,""Hello World!"");    
    u8g2.drawStr(2,30,s);    
    u8g2.drawFrame(0,0,u8g2.getDisplayWidth(),u8g2.getDisplayHeight() );

    u8g2.drawStr(2, 45, u8x8_u16toa(u8g2.getDisplayWidth(), 5));
    u8g2.drawStr(2, 60, u8x8_u16toa(u8g2.getDisplayHeight(), 5));
    
  } while ( u8g2.nextPage() );
  delay(2000);
}


void loop(void) {

  u8g2.clearDisplay();
  u8g2.setDisplayRotation(U8G2_R0);
  u8g2.setFlipMode(0);
  draw(""R0,F0"");
  u8g2.clearDisplay();
  u8g2.setFlipMode(1);
  draw(""R0,F1"");

  u8g2.clearDisplay();
  u8g2.setDisplayRotation(U8G2_R1);
  u8g2.setFlipMode(0);
  draw(""R1,F0"");
  u8g2.clearDisplay();
  u8g2.setFlipMode(1);
  draw(""R1,F1"");

  u8g2.clearDisplay();
  u8g2.setDisplayRotation(U8G2_R2);
  u8g2.setFlipMode(0);
  draw(""R2,F0"");
  u8g2.clearDisplay();
  u8g2.setFlipMode(1);
  draw(""R2,F1"");

  u8g2.clearDisplay();
  u8g2.setDisplayRotation(U8G2_R3);
  u8g2.setFlipMode(0);
  draw(""R3,F0"");
  u8g2.clearDisplay();
  u8g2.setFlipMode(1);
  draw(""R3,F1"");

}

",16247,True,4861.355001852905,median
"/*
Feathers
Copyright 2012-2013 Joshua Tynjala. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.controls
{
	import feathers.controls.renderers.DefaultGroupedListHeaderOrFooterRenderer;
	import feathers.controls.renderers.DefaultGroupedListItemRenderer;
	import feathers.controls.supportClasses.GroupedListDataViewPort;
	import feathers.core.IFocusDisplayObject;
	import feathers.core.PropertyProxy;
	import feathers.data.HierarchicalCollection;
	import feathers.events.CollectionEventType;
	import feathers.events.FeathersEventType;
	import feathers.layout.ILayout;
	import feathers.layout.VerticalLayout;

	import flash.geom.Point;
	import flash.ui.Keyboard;

	import starling.events.Event;
	import starling.events.KeyboardEvent;

	/**
	 * Dispatched when the selected item changes.
	 *
	 * @eventType starling.events.Event.CHANGE
	 */
	[Event(name=""change"",type=""starling.events.Event"")]

	/**
	 * Dispatched when an item renderer is added to the list. When the layout is
	 * virtualized, item renderers may not exist for every item in the data
	 * provider. This event can be used to track which items currently have
	 * renderers.
	 *
	 * @eventType feathers.events.FeathersEventType.RENDERER_ADD
	 */
	[Event(name=""rendererAdd"",type=""starling.events.Event"")]

	/**
	 * Dispatched when an item renderer is removed from the list. When the layout is
	 * virtualized, item renderers may not exist for every item in the data
	 * provider. This event can be used to track which items currently have
	 * renderers.
	 *
	 * @eventType feathers.events.FeathersEventType.RENDERER_REMOVE
	 */
	[Event(name=""rendererRemove"",type=""starling.events.Event"")]

	[DefaultProperty(""dataProvider"")]
	/**
	 * Displays a list of items divided into groups or sections. Takes a
	 * hierarchical provider limited to two levels of hierarchy. This component
	 * supports scrolling, custom item (and header and footer) renderers, and
	 * custom layouts.
	 *
	 * <p>Layouts may be, and are highly encouraged to be, <em>virtual</em>,
	 * meaning that the List is capable of creating a limited number of item
	 * renderers to display a subset of the data provider instead of creating a
	 * renderer for every single item. This allows for optimal performance with
	 * very large data providers.</p>
	 *
	 * @see http://wiki.starling-framework.org/feathers/grouped-list
	 */
	public class GroupedList extends Scroller implements IFocusDisplayObject
	{
		/**
		 * @private
		 */
		private static const HELPER_POINT:Point = new Point();

		/**
		 * An alternate name to use with GroupedList to allow a theme to give it
		 * an inset style. If a theme does not provide a skin for the inset
		 * grouped list, the theme will automatically fall back to using the
		 * default grouped list skin.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const ALTERNATE_NAME_INSET_GROUPED_LIST:String = ""feathers-inset-grouped-list"";

		/**
		 * The default name to use with header renderers.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_HEADER_RENDERER:String = ""feathers-grouped-list-header-renderer"";

		/**
		 * An alternate name to use with header renderers to give them an inset
		 * style.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const ALTERNATE_CHILD_NAME_INSET_HEADER_RENDERER:String = ""feathers-grouped-list-inset-header-renderer"";

		/**
		 * The default name to use with footer renderers.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_FOOTER_RENDERER:String = ""feathers-grouped-list-footer-renderer"";

		/**
		 * An alternate name to use with footer renderers to give them an inset
		 * style.
		 */
		public static const ALTERNATE_CHILD_NAME_INSET_FOOTER_RENDERER:String = ""feathers-grouped-list-inset-footer-renderer"";

		/**
		 * An alternate name to use with item renderers to give them an inset
		 * style.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const ALTERNATE_CHILD_NAME_INSET_ITEM_RENDERER:String = ""feathers-grouped-list-inset-item-renderer"";

		/**
		 * An alternate name to use for item renderers to give them an inset
		 * style. Typically meant to be used for the renderer of the first item
		 * in a group.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const ALTERNATE_CHILD_NAME_INSET_FIRST_ITEM_RENDERER:String = ""feathers-grouped-list-inset-first-item-renderer"";

		/**
		 * An alternate name to use for item renderers to give them an inset
		 * style. Typically meant to be used for the renderer of the last item
		 * in a group.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const ALTERNATE_CHILD_NAME_INSET_LAST_ITEM_RENDERER:String = ""feathers-grouped-list-inset-last-item-renderer"";

		/**
		 * An alternate name to use for item renderers to give them an inset
		 * style. Typically meant to be used for the renderer of an item in a
		 * group that has no other items.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const ALTERNATE_CHILD_NAME_INSET_SINGLE_ITEM_RENDERER:String = ""feathers-grouped-list-inset-single-item-renderer"";

		/**
		 * @copy feathers.controls.Scroller#SCROLL_POLICY_AUTO
		 */
		public static const SCROLL_POLICY_AUTO:String = ""auto"";

		/**
		 * @copy feathers.controls.Scroller#SCROLL_POLICY_ON
		 */
		public static const SCROLL_POLICY_ON:String = ""on"";

		/**
		 * @copy feathers.controls.Scroller#SCROLL_POLICY_OFF
		 */
		public static const SCROLL_POLICY_OFF:String = ""off"";

		/**
		 * @copy feathers.controls.Scroller#SCROLL_BAR_DISPLAY_MODE_FLOAT
		 */
		public static const SCROLL_BAR_DISPLAY_MODE_FLOAT:String = ""float"";

		/**
		 * @copy feathers.controls.Scroller#SCROLL_BAR_DISPLAY_MODE_FIXED
		 */
		public static const SCROLL_BAR_DISPLAY_MODE_FIXED:String = ""fixed"";

		/**
		 * @copy feathers.controls.Scroller#SCROLL_BAR_DISPLAY_MODE_NONE
		 */
		public static const SCROLL_BAR_DISPLAY_MODE_NONE:String = ""none"";

		/**
		 * @copy feathers.controls.Scroller#INTERACTION_MODE_TOUCH
		 */
		public static const INTERACTION_MODE_TOUCH:String = ""touch"";

		/**
		 * @copy feathers.controls.Scroller#INTERACTION_MODE_MOUSE
		 */
		public static const INTERACTION_MODE_MOUSE:String = ""mouse"";

		/**
		 * Constructor.
		 */
		public function GroupedList()
		{
			super();
			this.addEventListener(FeathersEventType.FOCUS_IN, list_focusInHandler);
			this.addEventListener(FeathersEventType.FOCUS_OUT, list_focusOutHandler);
		}

		/**
		 * @private
		 * The guts of the List's functionality. Handles layout and selection.
		 */
		protected var dataViewPort:GroupedListDataViewPort;

		/**
		 * @private
		 */
		protected var _layout:ILayout;

		/**
		 * The layout algorithm used to position and, optionally, size the
		 * list's items.
		 */
		public function get layout():ILayout
		{
			return this._layout;
		}

		/**
		 * @private
		 */
		public function set layout(value:ILayout):void
		{
			if(this._layout == value)
			{
				return;
			}
			this._layout = value;
			this.invalidate(INVALIDATION_FLAG_SCROLL);
		}

		/**
		 * @private
		 */
		protected var _dataProvider:HierarchicalCollection;

		/**
		 * The collection of data displayed by the list.
		 */
		public function get dataProvider():HierarchicalCollection
		{
			return this._dataProvider;
		}

		/**
		 * @private
		 */
		public function set dataProvider(value:HierarchicalCollection):void
		{
			if(this._dataProvider == value)
			{
				return;
			}
			if(this._dataProvider)
			{
				this._dataProvider.removeEventListener(CollectionEventType.RESET, dataProvider_resetHandler);
			}
			this._dataProvider = value;
			if(this._dataProvider)
			{
				this._dataProvider.addEventListener(CollectionEventType.RESET, dataProvider_resetHandler);
			}

			//reset the scroll position because this is a drastic change and
			//the data is probably completely different
			this.horizontalScrollPosition = 0;
			this.verticalScrollPosition = 0;

			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _isSelectable:Boolean = true;

		/**
		 * Determines if an item in the list may be selected.
		 */
		public function get isSelectable():Boolean
		{
			return this._isSelectable;
		}

		/**
		 * @private
		 */
		public function set isSelectable(value:Boolean):void
		{
			if(this._isSelectable == value)
			{
				return;
			}
			this._isSelectable = value;
			if(!this._isSelectable)
			{
				this.setSelectedLocation(-1, -1);
			}
			this.invalidate(INVALIDATION_FLAG_SELECTED);
		}

		/**
		 * @private
		 */
		protected var _selectedGroupIndex:int = -1;

		/**
		 * The group index of the currently selected item. Returns -1 if no item
		 * is selected.
		 *
		 * @see #selectedItemIndex
		 */
		public function get selectedGroupIndex():int
		{
			return this._selectedGroupIndex;
		}

		/**
		 * @private
		 */
		protected var _selectedItemIndex:int = -1;

		/**
		 * The item index of the currently selected item. Returns -1 if no item
		 * is selected.
		 *
		 * @see #selectedGroupIndex
		 */
		public function get selectedItemIndex():int
		{
			return this._selectedItemIndex;
		}

		/**
		 * The currently selected item. Returns null if no item is selected.
		 */
		public function get selectedItem():Object
		{
			if(!this._dataProvider || this._selectedGroupIndex < 0 || this._selectedItemIndex < 0)
			{
				return null;
			}

			return this._dataProvider.getItemAt(this._selectedGroupIndex, this._selectedItemIndex);
		}

		/**
		 * @private
		 */
		public function set selectedItem(value:Object):void
		{
			const result:Vector.<int> = this._dataProvider.getItemLocation(value);
			if(result.length == 2)
			{
				this.setSelectedLocation(result[0], result[1]);
			}
			else
			{
				this.setSelectedLocation(-1, -1);
			}
		}

		/**
		 * @private
		 */
		protected var _itemRendererType:Class = DefaultGroupedListItemRenderer;

		/**
		 * The class used to instantiate item renderers.
		 *
		 * @see feathers.controls.renderer.IGroupedListItemRenderer
		 * @see #itemRendererFactory
		 * @see #firstItemRendererType
		 * @see #firstItemRendererFactory
		 * @see #lastItemRendererType
		 * @see #lastItemRendererFactory
		 * @see #singleItemRendererType
		 * @see #singleItemRendererFactory
		 */
		public function get itemRendererType():Class
		{
			return this._itemRendererType;
		}

		/**
		 * @private
		 */
		public function set itemRendererType(value:Class):void
		{
			if(this._itemRendererType == value)
			{
				return;
			}

			this._itemRendererType = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _itemRendererFactory:Function;

		/**
		 * A function called that is expected to return a new item renderer. Has
		 * a higher priority than <code>itemRendererType</code>. Typically, you
		 * would use an <code>itemRendererFactory</code> instead of an
		 * <code>itemRendererType</code> if you wanted to initialize some
		 * properties on each separate item renderer, such as skins.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 *
		 * <pre>function():IGroupedListItemRenderer</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListItemRenderer
		 * @see #itemRendererType
		 * @see #firstItemRendererType
		 * @see #firstItemRendererFactory
		 * @see #lastItemRendererType
		 * @see #lastItemRendererFactory
		 * @see #singleItemRendererType
		 * @see #singleItemRendererFactory
		 */
		public function get itemRendererFactory():Function
		{
			return this._itemRendererFactory;
		}

		/**
		 * @private
		 */
		public function set itemRendererFactory(value:Function):void
		{
			if(this._itemRendererFactory === value)
			{
				return;
			}

			this._itemRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _typicalItem:Object = null;

		/**
		 * An item used to create a sample item renderer used for virtual layout
		 * measurement.
		 */
		public function get typicalItem():Object
		{
			return this._typicalItem;
		}

		/**
		 * @private
		 */
		public function set typicalItem(value:Object):void
		{
			if(this._typicalItem == value)
			{
				return;
			}
			this._typicalItem = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _itemRendererName:String;

		/**
		 * A name to add to all item renderers in this list. Typically used by a
		 * theme to provide different skins to different lists.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #firstItemRendererName
		 * @see #lastItemRendererName
		 * @see #singleItemRendererName
		 */
		public function get itemRendererName():String
		{
			return this._itemRendererName;
		}

		/**
		 * @private
		 */
		public function set itemRendererName(value:String):void
		{
			if(this._itemRendererName == value)
			{
				return;
			}
			this._itemRendererName = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _itemRendererProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to all of the list's item
		 * renderers. These values are shared by each item renderer, so values
		 * that cannot be shared (such as display objects that need to be added
		 * to the display list) should be passed to the item renderers using an
		 * <code>itemRendererFactory</code> or with a theme.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb of a <code>SimpleScrollBar</code>
		 * which is in a <code>Scroller</code> which is in a <code>List</code>,
		 * you can use the following syntax:</p>
		 * <pre>list.scrollerProperties.&#64;verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListItemRenderer
		 * @see #itemRendererFactory
		 */
		public function get itemRendererProperties():Object
		{
			if(!this._itemRendererProperties)
			{
				this._itemRendererProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._itemRendererProperties;
		}

		/**
		 * @private
		 */
		public function set itemRendererProperties(value:Object):void
		{
			if(this._itemRendererProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._itemRendererProperties)
			{
				this._itemRendererProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._itemRendererProperties = PropertyProxy(value);
			if(this._itemRendererProperties)
			{
				this._itemRendererProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _firstItemRendererType:Class;

		/**
		 * The class used to instantiate the item renderer for the first item in
		 * a group.
		 *
		 * @see feathers.controls.renderer.IGroupedListItemRenderer
		 * @see #firstItemRendererFactory
		 * @see #itemRendererType
		 * @see #itemRendererFactory
		 * @see #lastItemRendererType
		 * @see #lastItemRendererFactory
		 * @see #singleItemRendererType
		 * @see #singleItemRendererFactory
		 */
		public function get firstItemRendererType():Class
		{
			return this._firstItemRendererType;
		}

		/**
		 * @private
		 */
		public function set firstItemRendererType(value:Class):void
		{
			if(this._firstItemRendererType == value)
			{
				return;
			}

			this._firstItemRendererType = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _firstItemRendererFactory:Function;

		/**
		 * A function called that is expected to return a new item renderer for
		 * the first item in a group. Has a higher priority than
		 * <code>firstItemRendererType</code>. Typically, you would use an
		 * <code>firstItemRendererFactory</code> instead of an
		 * <code>firstItemRendererType</code> if you wanted to initialize some
		 * properties on each separate item renderer, such as skins.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 *
		 * <pre>function():IGroupedListItemRenderer</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListItemRenderer
		 * @see #firstItemRendererType
		 * @see #itemRendererType
		 * @see #itemRendererFactory
		 * @see #lastItemRendererType
		 * @see #lastItemRendererFactory
		 * @see #singleItemRendererType
		 * @see #singleItemRendererFactory
		 */
		public function get firstItemRendererFactory():Function
		{
			return this._firstItemRendererFactory;
		}

		/**
		 * @private
		 */
		public function set firstItemRendererFactory(value:Function):void
		{
			if(this._firstItemRendererFactory === value)
			{
				return;
			}

			this._firstItemRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _firstItemRendererName:String;

		/**
		 * A name to add to all item renderers in this list that are the first
		 * item in a group. Typically used by a theme to provide different skins
		 * to different lists, and to differentiate first items from regular
		 * items if they are created with the same class. If this value is null
		 * the regular <code>itemRendererName</code> will be used instead.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #itemRendererName
		 * @see #lastItemRendererName
		 * @see #singleItemRendererName
		 */
		public function get firstItemRendererName():String
		{
			return this._firstItemRendererName;
		}

		/**
		 * @private
		 */
		public function set firstItemRendererName(value:String):void
		{
			if(this._firstItemRendererName == value)
			{
				return;
			}
			this._firstItemRendererName = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _lastItemRendererType:Class;

		/**
		 * The class used to instantiate the item renderer for the last item in
		 * a group.
		 *
		 * @see feathers.controls.renderer.IGroupedListItemRenderer
		 * @see #lastItemRendererFactory
		 * @see #itemRendererType
		 * @see #itemRendererFactory
		 * @see #firstItemRendererType
		 * @see #firstItemRendererFactory
		 * @see #singleItemRendererType
		 * @see #singleItemRendererFactory
		 */
		public function get lastItemRendererType():Class
		{
			return this._lastItemRendererType;
		}

		/**
		 * @private
		 */
		public function set lastItemRendererType(value:Class):void
		{
			if(this._lastItemRendererType == value)
			{
				return;
			}

			this._lastItemRendererType = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _lastItemRendererFactory:Function;

		/**
		 * A function called that is expected to return a new item renderer for
		 * the last item in a group. Has a higher priority than
		 * <code>lastItemRendererType</code>. Typically, you would use an
		 * <code>lastItemRendererFactory</code> instead of an
		 * <code>lastItemRendererType</code> if you wanted to initialize some
		 * properties on each separate item renderer, such as skins.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 *
		 * <pre>function():IGroupedListItemRenderer</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListItemRenderer
		 * @see #lastItemRendererType
		 * @see #itemRendererType
		 * @see #itemRendererFactory
		 * @see #firstItemRendererType
		 * @see #firstItemRendererFactory
		 * @see #singleItemRendererType
		 * @see #singleItemRendererFactory
		 */
		public function get lastItemRendererFactory():Function
		{
			return this._lastItemRendererFactory;
		}

		/**
		 * @private
		 */
		public function set lastItemRendererFactory(value:Function):void
		{
			if(this._lastItemRendererFactory === value)
			{
				return;
			}

			this._lastItemRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _lastItemRendererName:String;

		/**
		 * A name to add to all item renderers in this list that are the last
		 * item in a group. Typically used by a theme to provide different skins
		 * to different lists, and to differentiate last items from regular
		 * items if they are created with the same class. If this value is null
		 * the regular <code>itemRendererName</code> will be used instead.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #itemRendererName
		 * @see #firstItemRendererName
		 * @see #singleItemRendererName
		 */
		public function get lastItemRendererName():String
		{
			return this._lastItemRendererName;
		}

		/**
		 * @private
		 */
		public function set lastItemRendererName(value:String):void
		{
			if(this._lastItemRendererName == value)
			{
				return;
			}
			this._lastItemRendererName = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _singleItemRendererType:Class;

		/**
		 * The class used to instantiate the item renderer for an item in a
		 * group with no other items.
		 *
		 * @see feathers.controls.renderer.IGroupedListItemRenderer
		 * @see #singleItemRendererFactory
		 * @see #itemRendererType
		 * @see #itemRendererFactory
		 * @see #firstItemRendererType
		 * @see #firstItemRendererFactory
		 * @see #lastItemRendererType
		 * @see #lastItemRendererFactory
		 */
		public function get singleItemRendererType():Class
		{
			return this._singleItemRendererType;
		}

		/**
		 * @private
		 */
		public function set singleItemRendererType(value:Class):void
		{
			if(this._singleItemRendererType == value)
			{
				return;
			}

			this._singleItemRendererType = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _singleItemRendererFactory:Function;

		/**
		 * A function called that is expected to return a new item renderer for
		 * an item in a group with no other items. Has a higher priority than
		 * <code>singleItemRendererType</code>. Typically, you would use an
		 * <code>singleItemRendererFactory</code> instead of an
		 * <code>singleItemRendererType</code> if you wanted to initialize some
		 * properties on each separate item renderer, such as skins.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 *
		 * <pre>function():IGroupedListItemRenderer</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListItemRenderer
		 * @see #singleItemRendererType
		 * @see #itemRendererType
		 * @see #itemRendererFactory
		 * @see #firstItemRendererType
		 * @see #firstItemRendererFactory
		 * @see #lastItemRendererType
		 * @see #lastItemRendererFactory
		 */
		public function get singleItemRendererFactory():Function
		{
			return this._singleItemRendererFactory;
		}

		/**
		 * @private
		 */
		public function set singleItemRendererFactory(value:Function):void
		{
			if(this._singleItemRendererFactory === value)
			{
				return;
			}

			this._singleItemRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _singleItemRendererName:String;

		/**
		 * A name to add to all item renderers in this list that are an item in
		 * a group with no other items. Typically used by a theme to provide
		 * different skins to different lists, and to differentiate single items
		 * from other items if they are created with the same class. If this
		 * value is null the regular <code>itemRendererName</code> will be used
		 * instead.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #itemRendererName
		 * @see #firstItemRendererName
		 * @see #lastItemRendererName
		 */
		public function get singleItemRendererName():String
		{
			return this._singleItemRendererName;
		}

		/**
		 * @private
		 */
		public function set singleItemRendererName(value:String):void
		{
			if(this._singleItemRendererName == value)
			{
				return;
			}
			this._singleItemRendererName = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _headerRendererType:Class = DefaultGroupedListHeaderOrFooterRenderer;

		/**
		 * The class used to instantiate header renderers.
		 *
		 * @see feathers.controls.renderers.IGroupedListHeaderOrFooterRenderer
		 * @see #headerRendererFactory
		 */
		public function get headerRendererType():Class
		{
			return this._headerRendererType;
		}

		/**
		 * @private
		 */
		public function set headerRendererType(value:Class):void
		{
			if(this._headerRendererType == value)
			{
				return;
			}

			this._headerRendererType = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _headerRendererFactory:Function;

		/**
		 * A function called that is expected to return a new header renderer.
		 * Has a higher priority than <code>headerRendererType</code>.
		 * Typically, you would use an <code>headerRendererFactory</code>
		 * instead of a <code>headerRendererType</code> if you wanted to
		 * initialize some properties on each separate header renderer, such as
		 * skins.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 *
		 * <pre>function():IGroupedListHeaderOrFooterRenderer</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListHeaderOrFooterRenderer
		 * @see #headerRendererType
		 */
		public function get headerRendererFactory():Function
		{
			return this._headerRendererFactory;
		}

		/**
		 * @private
		 */
		public function set headerRendererFactory(value:Function):void
		{
			if(this._headerRendererFactory === value)
			{
				return;
			}

			this._headerRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _typicalHeader:Object = null;

		/**
		 * Used to auto-size the grouped list. If the list's width or height is
		 * NaN, the grouped list will try to automatically pick an ideal size.
		 * This data is used in that process to create a sample header renderer.
		 */
		public function get typicalHeader():Object
		{
			return this._typicalHeader;
		}

		/**
		 * @private
		 */
		public function set typicalHeader(value:Object):void
		{
			if(this._typicalHeader == value)
			{
				return;
			}
			this._typicalHeader = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _headerRendererName:String = DEFAULT_CHILD_NAME_HEADER_RENDERER;

		/**
		 * A name to add to all header renderers in this grouped list. Typically
		 * used by a theme to provide different skins to different lists.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 */
		public function get headerRendererName():String
		{
			return this._headerRendererName;
		}

		/**
		 * @private
		 */
		public function set headerRendererName(value:String):void
		{
			if(this._headerRendererName == value)
			{
				return;
			}
			this._headerRendererName = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _headerRendererProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to all of the grouped
		 * list's header renderers. These values are shared by each header
		 * renderer, so values that cannot be shared (such as display objects
		 * that need to be added to the display list) should be passed to the
		 * header renderers using a <code>headerRendererFactory</code> or with a
		 * theme.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb of a <code>SimpleScrollBar</code>
		 * which is in a <code>Scroller</code> which is in a <code>List</code>,
		 * you can use the following syntax:</p>
		 * <pre>list.scrollerProperties.&#64;verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * @see #headerRendererFactory
		 */
		public function get headerRendererProperties():Object
		{
			if(!this._headerRendererProperties)
			{
				this._headerRendererProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._headerRendererProperties;
		}

		/**
		 * @private
		 */
		public function set headerRendererProperties(value:Object):void
		{
			if(this._headerRendererProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._headerRendererProperties)
			{
				this._headerRendererProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._headerRendererProperties = PropertyProxy(value);
			if(this._headerRendererProperties)
			{
				this._headerRendererProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _footerRendererType:Class = DefaultGroupedListHeaderOrFooterRenderer;

		/**
		 * The class used to instantiate footer renderers.
		 *
		 * @see feathers.controls.renderers.IGroupedListHeaderOrFooterRenderer
		 * @see #footerRendererFactory
		 */
		public function get footerRendererType():Class
		{
			return this._footerRendererType;
		}

		/**
		 * @private
		 */
		public function set footerRendererType(value:Class):void
		{
			if(this._footerRendererType == value)
			{
				return;
			}

			this._footerRendererType = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _footerRendererFactory:Function;

		/**
		 * A function called that is expected to return a new footer renderer.
		 * Has a higher priority than <code>footerRendererType</code>.
		 * Typically, you would use an <code>footerRendererFactory</code>
		 * instead of a <code>footerRendererType</code> if you wanted to
		 * initialize some properties on each separate footer renderer, such as
		 * skins.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 *
		 * <pre>function():IGroupedListHeaderOrFooterRenderer</pre>
		 *
		 * @see feathers.controls.renderers.IGroupedListHeaderOrFooterRenderer
		 * @see #footerRendererType
		 */
		public function get footerRendererFactory():Function
		{
			return this._footerRendererFactory;
		}

		/**
		 * @private
		 */
		public function set footerRendererFactory(value:Function):void
		{
			if(this._footerRendererFactory === value)
			{
				return;
			}

			this._footerRendererFactory = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _typicalFooter:Object = null;

		/**
		 * Used to auto-size the grouped list. If the grouped list's width or
		 * height is NaN, the grouped list will try to automatically pick an
		 * ideal size. This data is used in that process to create a sample
		 * footer renderer.
		 */
		public function get typicalFooter():Object
		{
			return this._typicalFooter;
		}

		/**
		 * @private
		 */
		public function set typicalFooter(value:Object):void
		{
			if(this._typicalFooter == value)
			{
				return;
			}
			this._typicalFooter = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _footerRendererName:String = DEFAULT_CHILD_NAME_FOOTER_RENDERER;

		/**
		 * A name to add to all footer renderers in this grouped list. Typically
		 * used by a theme to provide different skins to different lists.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 */
		public function get footerRendererName():String
		{
			return this._footerRendererName;
		}

		/**
		 * @private
		 */
		public function set footerRendererName(value:String):void
		{
			if(this._footerRendererName == value)
			{
				return;
			}
			this._footerRendererName = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _footerRendererProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to all of the grouped
		 * list's footer renderers. These values are shared by each footer
		 * renderer, so values that cannot be shared (such as display objects
		 * that need to be added to the display list) should be passed to the
		 * footer renderers using a <code>footerRendererFactory</code> or with
		 * a theme.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb of a <code>SimpleScrollBar</code>
		 * which is in a <code>Scroller</code> which is in a <code>List</code>,
		 * you can use the following syntax:</p>
		 * <pre>list.scrollerProperties.&#64;verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * @see #itemRendererFactory
		 */
		public function get footerRendererProperties():Object
		{
			if(!this._footerRendererProperties)
			{
				this._footerRendererProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._footerRendererProperties;
		}

		/**
		 * @private
		 */
		public function set footerRendererProperties(value:Object):void
		{
			if(this._footerRendererProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._footerRendererProperties)
			{
				this._footerRendererProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._footerRendererProperties = PropertyProxy(value);
			if(this._footerRendererProperties)
			{
				this._footerRendererProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _headerField:String = ""header"";

		/**
		 * The field in a group that contains the data for a header. If the
		 * group does not have this field, and a <code>headerFunction</code> is
		 * not defined, then no header will be displayed for the group. In other
		 * words, a header is optional, and a group may not have one.
		 *
		 * <p>All of the header fields and functions, ordered by priority:</p>
		 * <ol>
		 *     <li><code>headerFunction</code></li>
		 *     <li><code>headerField</code></li>
		 * </ol>
		 *
		 * @see #headerFunction
		 */
		public function get headerField():String
		{
			return this._headerField;
		}

		/**
		 * @private
		 */
		public function set headerField(value:String):void
		{
			if(this._headerField == value)
			{
				return;
			}
			this._headerField = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _headerFunction:Function;

		/**
		 * A function used to generate header data for a specific group. If this
		 * function is not null, then the <code>headerField</code> will be
		 * ignored.
		 *
		 * <p>All of the header fields and functions, ordered by priority:</p>
		 * <ol>
		 *     <li><code>headerFunction</code></li>
		 *     <li><code>headerField</code></li>
		 * </ol>
		 *
		 * @see #headerField
		 */
		public function get headerFunction():Function
		{
			return this._headerFunction;
		}

		/**
		 * @private
		 */
		public function set headerFunction(value:Function):void
		{
			if(this._headerFunction == value)
			{
				return;
			}
			this._headerFunction = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _footerField:String = ""footer"";

		/**
		 * The field in a group that contains the data for a footer. If the
		 * group does not have this field, and a <code>footerFunction</code> is
		 * not defined, then no footer will be displayed for the group. In other
		 * words, a footer is optional, and a group may not have one.
		 *
		 * <p>All of the footer fields and functions, ordered by priority:</p>
		 * <ol>
		 *     <li><code>footerFunction</code></li>
		 *     <li><code>footerField</code></li>
		 * </ol>
		 *
		 * @see #footerFunction
		 */
		public function get footerField():String
		{
			return this._footerField;
		}

		/**
		 * @private
		 */
		public function set footerField(value:String):void
		{
			if(this._footerField == value)
			{
				return;
			}
			this._footerField = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _footerFunction:Function;

		/**
		 * A function used to generate footer data for a specific group. If this
		 * function is not null, then the <code>footerField</code> will be
		 * ignored.
		 *
		 * <p>All of the footer fields and functions, ordered by priority:</p>
		 * <ol>
		 *     <li><code>footerFunction</code></li>
		 *     <li><code>footerField</code></li>
		 * </ol>
		 *
		 * @see #footerField
		 */
		public function get footerFunction():Function
		{
			return this._footerFunction;
		}

		/**
		 * @private
		 */
		public function set footerFunction(value:Function):void
		{
			if(this._footerFunction == value)
			{
				return;
			}
			this._footerFunction = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * The pending group index to scroll to after validating. A value of
		 * <code>-1</code> means that the scroller won't scroll to a group after
		 * validating.
		 */
		protected var pendingGroupIndex:int = -1;

		/**
		 * The pending item index to scroll to after validating. A value of
		 * <code>-1</code> means that the scroller won't scroll to an item after
		 * validating.
		 */
		protected var pendingItemIndex:int = -1;

		/**
		 * @private
		 */
		override public function scrollToPosition(horizontalScrollPosition:Number, verticalScrollPosition:Number, animationDuration:Number = 0):void
		{
			this.pendingItemIndex = -1;
			super.scrollToPosition(horizontalScrollPosition, verticalScrollPosition, animationDuration);
		}

		/**
		 * @private
		 */
		override public function scrollToPageIndex(horizontalPageIndex:int, verticalPageIndex:int, animationDuration:Number = 0):void
		{
			this.pendingGroupIndex = -1;
			this.pendingItemIndex = -1;
			super.scrollToPageIndex(horizontalPageIndex, verticalPageIndex, animationDuration);
		}

		/**
		 * After the next validation, scrolls the list so that the specified
		 * item is visible. If <code>animationDuration</code> is greater than
		 * zero, the scroll will animate. The duration is in seconds.
		 */
		public function scrollToDisplayIndex(groupIndex:int, itemIndex:int, animationDuration:Number = 0):void
		{
			this.pendingHorizontalPageIndex = -1;
			this.pendingVerticalPageIndex = -1;
			this.pendingHorizontalScrollPosition = NaN;
			this.pendingVerticalScrollPosition = NaN;
			if(this.pendingGroupIndex == groupIndex &&
				this.pendingItemIndex == itemIndex &&
				this.pendingScrollDuration == animationDuration)
			{
				return;
			}
			this.pendingGroupIndex = groupIndex;
			this.pendingItemIndex = itemIndex;
			this.pendingScrollDuration = animationDuration;
			this.invalidate(INVALIDATION_FLAG_PENDING_SCROLL);
		}

		/**
		 * Sets the selected group and item index.
		 */
		public function setSelectedLocation(groupIndex:int, itemIndex:int):void
		{
			if(this._selectedGroupIndex == groupIndex && this._selectedItemIndex == itemIndex)
			{
				return;
			}
			if((groupIndex < 0 && itemIndex >= 0) || (groupIndex >= 0 && itemIndex < 0))
			{
				throw new ArgumentError(""To deselect items, group index and item index must both be < 0."");
			}
			this._selectedGroupIndex = groupIndex;
			this._selectedItemIndex = itemIndex;

			this.invalidate(INVALIDATION_FLAG_SELECTED);
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * Extracts header data from a group object.
		 */
		public function groupToHeaderData(group:Object):Object
		{
			if(this._headerFunction != null)
			{
				return this._headerFunction(group);
			}
			else if(this._headerField != null && group && group.hasOwnProperty(this._headerField))
			{
				return group[this._headerField];
			}

			return null;
		}

		/**
		 * Extracts footer data from a group object.
		 */
		public function groupToFooterData(group:Object):Object
		{
			if(this._footerFunction != null)
			{
				return this._footerFunction(group);
			}
			else if(this._footerField != null && group && group.hasOwnProperty(this._footerField))
			{
				return group[this._footerField];
			}

			return null;
		}

		/**
		 * @private
		 */
		override protected function initialize():void
		{
			const hasLayout:Boolean = this._layout != null;

			super.initialize();

			if(!this.dataViewPort)
			{
				this.viewPort = this.dataViewPort = new GroupedListDataViewPort();
				this.dataViewPort.owner = this;
				this.dataViewPort.addEventListener(Event.CHANGE, dataViewPort_changeHandler);
				this.viewPort = this.dataViewPort;
			}

			if(!hasLayout)
			{
				if(this._hasElasticEdges &&
					this._verticalScrollPolicy == SCROLL_POLICY_AUTO &&
					this._scrollBarDisplayMode != SCROLL_BAR_DISPLAY_MODE_FIXED)
				{
					//so that the elastic edges work even when the max scroll
					//position is 0, similar to iOS.
					this.verticalScrollPolicy = SCROLL_POLICY_ON;
				}

				const layout:VerticalLayout = new VerticalLayout();
				layout.useVirtualLayout = true;
				layout.paddingTop = layout.paddingRight = layout.paddingBottom =
					layout.paddingLeft = 0;
				layout.gap = 0;
				layout.horizontalAlign = VerticalLayout.HORIZONTAL_ALIGN_JUSTIFY;
				layout.verticalAlign = VerticalLayout.VERTICAL_ALIGN_TOP;
				this._layout = layout;
			}
		}

		/**
		 * @private
		 */
		override protected function draw():void
		{
			this.refreshDataViewPortProperties();
			super.draw();
		}

		/**
		 * @private
		 */
		protected function refreshDataViewPortProperties():void
		{
			this.dataViewPort.isSelectable = this._isSelectable;
			this.dataViewPort.setSelectedLocation(this._selectedGroupIndex, this._selectedItemIndex);
			this.dataViewPort.dataProvider = this._dataProvider;

			this.dataViewPort.itemRendererType = this._itemRendererType;
			this.dataViewPort.itemRendererFactory = this._itemRendererFactory;
			this.dataViewPort.itemRendererProperties = this._itemRendererProperties;
			this.dataViewPort.itemRendererName = this._itemRendererName;
			this.dataViewPort.typicalItem = this._typicalItem;

			this.dataViewPort.firstItemRendererType = this._firstItemRendererType;
			this.dataViewPort.firstItemRendererFactory = this._firstItemRendererFactory;
			this.dataViewPort.firstItemRendererName = this._firstItemRendererName;

			this.dataViewPort.lastItemRendererType = this._lastItemRendererType;
			this.dataViewPort.lastItemRendererFactory = this._lastItemRendererFactory;
			this.dataViewPort.lastItemRendererName = this._lastItemRendererName;

			this.dataViewPort.singleItemRendererType = this._singleItemRendererType;
			this.dataViewPort.singleItemRendererFactory = this._singleItemRendererFactory;
			this.dataViewPort.singleItemRendererName = this._singleItemRendererName;

			this.dataViewPort.headerRendererType = this._headerRendererType;
			this.dataViewPort.headerRendererFactory = this._headerRendererFactory;
			this.dataViewPort.headerRendererProperties = this._headerRendererProperties;
			this.dataViewPort.headerRendererName = this._headerRendererName;
			this.dataViewPort.typicalHeader = this._typicalHeader;

			this.dataViewPort.footerRendererType = this._footerRendererType;
			this.dataViewPort.footerRendererFactory = this._footerRendererFactory;
			this.dataViewPort.footerRendererProperties = this._footerRendererProperties;
			this.dataViewPort.footerRendererName = this._footerRendererName;
			this.dataViewPort.typicalFooter = this._typicalFooter;

			this.dataViewPort.layout = this._layout;
		}

		/**
		 * @private
		 */
		override protected function handlePendingScroll():void
		{
			if(this.pendingGroupIndex >= 0 && this.pendingItemIndex >= 0)
			{
				const item:Object = this._dataProvider.getItemAt(this.pendingGroupIndex, this.pendingItemIndex);
				if(item is Object)
				{
					this.dataViewPort.getScrollPositionForIndex(this.pendingGroupIndex, this.pendingItemIndex, HELPER_POINT);
					this.pendingGroupIndex = -1;
					this.pendingItemIndex = -1;

					if(this.pendingScrollDuration > 0)
					{
						this.throwTo(Math.max(0, Math.min(HELPER_POINT.x, this._maxHorizontalScrollPosition)),
							Math.max(0, Math.min(HELPER_POINT.y, this._maxVerticalScrollPosition)), this.pendingScrollDuration);
					}
					else
					{
						this.horizontalScrollPosition = Math.max(0, Math.min(HELPER_POINT.x, this._maxHorizontalScrollPosition));
						this.verticalScrollPosition = Math.max(0, Math.min(HELPER_POINT.y, this._maxVerticalScrollPosition));
					}
				}
			}
			super.handlePendingScroll();
		}

		/**
		 * @private
		 */
		protected function list_focusInHandler(event:Event):void
		{
			this.stage.addEventListener(KeyboardEvent.KEY_DOWN, stage_keyDownHandler);
		}

		/**
		 * @private
		 */
		protected function list_focusOutHandler(event:Event):void
		{
			this.stage.removeEventListener(KeyboardEvent.KEY_DOWN, stage_keyDownHandler);
		}

		/**
		 * @private
		 */
		protected function stage_keyDownHandler(event:KeyboardEvent):void
		{
			if(!this._dataProvider)
			{
				return;
			}
			if(event.keyCode == Keyboard.HOME)
			{
				if(this._dataProvider.getLength() > 0 && this._dataProvider.getLength(0) > 0)
				{
					this.setSelectedLocation(0, 0);
				}
			}
			if(event.keyCode == Keyboard.END)
			{
				var groupIndex:int = this._dataProvider.getLength();
				var itemIndex:int = -1;
				do
				{
					groupIndex--;
					if(groupIndex >= 0)
					{
						itemIndex = this._dataProvider.getLength(groupIndex) - 1;
					}
				}
				while(groupIndex > 0 && itemIndex < 0)
				if(groupIndex >= 0 && itemIndex >= 0)
				{
					this.setSelectedLocation(groupIndex, itemIndex);
				}
			}
			else if(event.keyCode == Keyboard.UP)
			{
				groupIndex = this._selectedGroupIndex;
				itemIndex = this._selectedItemIndex - 1;
				if(itemIndex < 0)
				{
					do
					{
						groupIndex--;
						if(groupIndex >= 0)
						{
							itemIndex = this._dataProvider.getLength(groupIndex) - 1;
						}
					}
					while(groupIndex > 0 && itemIndex < 0)
				}
				if(groupIndex >= 0 && itemIndex >= 0)
				{
					this.setSelectedLocation(groupIndex, itemIndex);
				}
			}
			else if(event.keyCode == Keyboard.DOWN)
			{
				groupIndex = this._selectedGroupIndex;
				if(groupIndex < 0)
				{
					itemIndex = -1;
				}
				else
				{
					itemIndex = this._selectedItemIndex + 1;
				}
				if(groupIndex < 0 || itemIndex >= this._dataProvider.getLength(groupIndex))
				{
					itemIndex = -1;
					groupIndex++;
					const groupCount:int = this._dataProvider.getLength();
					while(groupIndex < groupCount && itemIndex < 0)
					{
						if(this._dataProvider.getLength(groupIndex) > 0)
						{
							itemIndex = 0;
						}
						else
						{
							groupIndex++;
						}
					}
				}
				if(groupIndex >= 0 && itemIndex >= 0)
				{
					this.setSelectedLocation(groupIndex, itemIndex);
				}
			}
		}

		/**
		 * @private
		 */
		protected function dataProvider_resetHandler(event:Event):void
		{
			this.horizontalScrollPosition = 0;
			this.verticalScrollPosition = 0;
		}

		/**
		 * @private
		 */
		protected function dataViewPort_changeHandler(event:Event):void
		{
			this.setSelectedLocation(this.dataViewPort.selectedGroupIndex, this.dataViewPort.selectedItemIndex);
		}
	}
}
",12390,True,2946.7979181441397,median
"/*

  GraphicsTest.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8glib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display




// End of constructor list


void u8g2_prepare(void) {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}

void u8g2_box_title(uint8_t a) {
  u8g2.drawStr( 10+a*2, 5, ""U8g2"");
  u8g2.drawStr( 10, 20, ""GraphicsTest"");
  
  u8g2.drawFrame(0,0,u8g2.getDisplayWidth(),u8g2.getDisplayHeight() );
}

void u8g2_box_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawBox"");
  u8g2.drawBox(5,10,20,10);
  u8g2.drawBox(10+a,15,30,7);
  u8g2.drawStr( 0, 30, ""drawFrame"");
  u8g2.drawFrame(5,10+30,20,10);
  u8g2.drawFrame(10+a,15+30,30,7);
}

void u8g2_disc_circle(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawDisc"");
  u8g2.drawDisc(10,18,9);
  u8g2.drawDisc(24+a,16,7);
  u8g2.drawStr( 0, 30, ""drawCircle"");
  u8g2.drawCircle(10,18+30,9);
  u8g2.drawCircle(24+a,16+30,7);
}

void u8g2_r_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawRFrame/Box"");
  u8g2.drawRFrame(5, 10,40,30, a+1);
  u8g2.drawRBox(50, 10,25,40, a+1);
}

void u8g2_string(uint8_t a) {
  u8g2.setFontDirection(0);
  u8g2.drawStr(30+a,31, "" 0"");
  u8g2.setFontDirection(1);
  u8g2.drawStr(30,31+a, "" 90"");
  u8g2.setFontDirection(2);
  u8g2.drawStr(30-a,31, "" 180"");
  u8g2.setFontDirection(3);
  u8g2.drawStr(30,31-a, "" 270"");
}

void u8g2_line(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawLine"");
  u8g2.drawLine(7+a, 10, 40, 55);
  u8g2.drawLine(7+a*2, 10, 60, 55);
  u8g2.drawLine(7+a*3, 10, 80, 55);
  u8g2.drawLine(7+a*4, 10, 100, 55);
}

void u8g2_triangle(uint8_t a) {
  uint16_t offset = a;
  u8g2.drawStr( 0, 0, ""drawTriangle"");
  u8g2.drawTriangle(14,7, 45,30, 10,40);
  u8g2.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);
  u8g2.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);
  u8g2.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);
}

void u8g2_ascii_1() {
  char s[2] = "" "";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, ""ASCII page 1"");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 32;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_ascii_2() {
  char s[2] = "" "";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, ""ASCII page 2"");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 160;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_extra_page(uint8_t a)
{
  u8g2.drawStr( 0, 0, ""Unicode"");
  u8g2.setFont(u8g2_font_unifont_t_symbols);
  u8g2.setFontPosTop();
  u8g2.drawUTF8(0, 24, ""☀ ☁"");
  switch(a) {
    case 0:
    case 1:
    case 2:
    case 3:
      u8g2.drawUTF8(a*3, 36, ""☂"");
      break;
    case 4:
    case 5:
    case 6:
    case 7:
      u8g2.drawUTF8(a*3, 36, ""☔"");
      break;
  }
}

void u8g2_xor(uint8_t a) {
  uint8_t i;
  u8g2.drawStr( 0, 0, ""XOR"");
  u8g2.setFontMode(1);
  u8g2.setDrawColor(2);
  for( i = 0; i < 5; i++)
  {
    u8g2.drawBox(10+i*16, 18 + (i&1)*4, 21,31);
  }
  u8g2.drawStr( 5+a, 19, ""XOR XOR XOR XOR"");
  u8g2.setDrawColor(0);
  u8g2.drawStr( 5+a, 29, ""CLR CLR CLR CLR"");
  u8g2.setDrawColor(1);
  u8g2.drawStr( 5+a, 39, ""SET SET SET SET"");
  u8g2.setFontMode(0);
    
}

#define cross_width 24
#define cross_height 24
static const unsigned char cross_bits[] U8X8_PROGMEM  = {
  0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 
  0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80, 
  0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03, 
  0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, };

#define cross_fill_width 24
#define cross_fill_height 24
static const unsigned char cross_fill_bits[] U8X8_PROGMEM  = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26, 
  0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08, 
  0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01, 
  0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04, 
  0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21, 
  0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

#define cross_block_width 14
#define cross_block_height 14
static const unsigned char cross_block_bits[] U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0x01, 0x20, 0xFF, 0x3F, };

void u8g2_bitmap_overlay(uint8_t a) {
  uint8_t frame_size = 28;

  u8g2.drawStr(0, 0, ""Bitmap overlay"");

  u8g2.drawStr(0, frame_size + 12, ""Solid / transparent"");
  u8g2.setBitmapMode(false /* solid */);
  u8g2.drawFrame(0, 10, frame_size, frame_size);
  u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);

  u8g2.setBitmapMode(true /* transparent*/);
  u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);
  u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);
}

void u8g2_bitmap_modes(uint8_t transparent) {
  const uint8_t frame_size = 24;

  u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);
  u8g2.drawStr(frame_size * 0.5, 50, ""Black"");
  u8g2.drawStr(frame_size * 2, 50, ""White"");
  u8g2.drawStr(frame_size * 3.5, 50, ""XOR"");
  
  if(!transparent) {
    u8g2.setBitmapMode(false /* solid */);
    u8g2.drawStr(0, 0, ""Solid bitmap"");
  } else {
    u8g2.setBitmapMode(true /* transparent*/);
    u8g2.drawStr(0, 0, ""Transparent bitmap"");
  }
  u8g2.setDrawColor(0);// Black
  u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(1); // White
  u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(2); // XOR
  u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);
}

uint8_t draw_state = 0;

void draw(void) {
  u8g2_prepare();
  switch(draw_state >> 3) {
    case 0: u8g2_box_title(draw_state&7); break;
    case 1: u8g2_box_frame(draw_state&7); break;
    case 2: u8g2_disc_circle(draw_state&7); break;
    case 3: u8g2_r_frame(draw_state&7); break;
    case 4: u8g2_string(draw_state&7); break;
    case 5: u8g2_line(draw_state&7); break;
    case 6: u8g2_triangle(draw_state&7); break;
    case 7: u8g2_ascii_1(); break;
    case 8: u8g2_ascii_2(); break;
    case 9: u8g2_extra_page(draw_state&7); break;
    case 10: u8g2_xor(draw_state&7); break;
    case 11: u8g2_bitmap_modes(0); break;
    case 12: u8g2_bitmap_modes(1); break;
    case 13: u8g2_bitmap_overlay(draw_state&7); break;
  }
}


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  digitalWrite(10, 0);
  digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  u8g2.begin();
  //u8g2.setFlipMode(0);
}

void loop(void) {
  // picture loop  
  u8g2.firstPage();  
  do {
    draw();
  } while( u8g2.nextPage() );
  
  // increase the state
  draw_state++;
  if ( draw_state >= 14*8 )
    draw_state = 0;

  // delay between each page
  delay(150);

}
",16215,True,3592.0379464922257,median
"/*

  Weather.ino
  
  Demonstrates:
    - Weather icons from open-iconic set.
    - Text scrolling.
    - Partial screen update
    
  This example requires display height >= 64.

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list




#define SUN	0
#define SUN_CLOUD  1
#define CLOUD 2
#define RAIN 3
#define THUNDER 4

void drawWeatherSymbol(u8g2_uint_t x, u8g2_uint_t y, uint8_t symbol)
{
  // fonts used:
  // u8g2_font_open_iconic_embedded_6x_t
  // u8g2_font_open_iconic_weather_6x_t
  // encoding values, see: https://github.com/olikraus/u8g2/wiki/fntgrpiconic
  
  switch(symbol)
  {
    case SUN:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 69);	
      break;
    case SUN_CLOUD:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 65);	
      break;
    case CLOUD:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 64);	
      break;
    case RAIN:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 67);	
      break;
    case THUNDER:
      u8g2.setFont(u8g2_font_open_iconic_embedded_6x_t);
      u8g2.drawGlyph(x, y, 67);
      break;      
  }
}

void drawWeather(uint8_t symbol, int degree)
{
  drawWeatherSymbol(0, 48, symbol);
  u8g2.setFont(u8g2_font_logisoso32_tf);
  u8g2.setCursor(48+3, 42);
  u8g2.print(degree);
  u8g2.print(""°C"");		// requires enableUTF8Print()
}

/*
  Draw a string with specified pixel offset. 
  The offset can be negative.
  Limitation: The monochrome font with 8 pixel per glyph
*/
void drawScrollString(int16_t offset, const char *s)
{
  static char buf[36];	// should for screen with up to 256 pixel width 
  size_t len;
  size_t char_offset = 0;
  u8g2_uint_t dx = 0;
  size_t visible = 0;
  

  u8g2.setDrawColor(0);		// clear the scrolling area
  u8g2.drawBox(0, 49, u8g2.getDisplayWidth()-1, u8g2.getDisplayHeight()-1);
  u8g2.setDrawColor(1);		// set the color for the text
    
  
  len = strlen(s);
  if ( offset < 0 )
  {
    char_offset = (-offset)/8;
    dx = offset + char_offset*8;
    if ( char_offset >= u8g2.getDisplayWidth()/8 )
      return;
    visible = u8g2.getDisplayWidth()/8-char_offset+1;
    strncpy(buf, s, visible);
    buf[visible] = '\\0';
    u8g2.setFont(u8g2_font_8x13_mf);
    u8g2.drawStr(char_offset*8-dx, 62, buf);
  }
  else
  {
    char_offset = offset / 8;
    if ( char_offset >= len )
      return;	// nothing visible
    dx = offset - char_offset*8;
    visible = len - char_offset;
    if ( visible > u8g2.getDisplayWidth()/8+1 )
      visible = u8g2.getDisplayWidth()/8+1;
    strncpy(buf, s+char_offset, visible);
    buf[visible] = '\\0';
    u8g2.setFont(u8g2_font_8x13_mf);
    u8g2.drawStr(-dx, 62, buf);
  }
  
}

void draw(const char *s, uint8_t symbol, int degree)
{
  int16_t offset = -(int16_t)u8g2.getDisplayWidth();
  int16_t len = strlen(s);
  
  u8g2.clearBuffer();					// clear the internal memory
  drawWeather(symbol, degree);		// draw the icon and degree only once
  for(;;)							// then do the scrolling
  {
  
    drawScrollString(offset, s);  			// no clearBuffer required, screen will be partially cleared here
    u8g2.sendBuffer();				// transfer internal memory to the display

    delay(20);
    offset+=2;
    if ( offset > len*8+1 )
      break;
  }
}


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  
  digitalWrite(10, 0);
  digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
  u8g2.enableUTF8Print();
}

void loop(void) {

  draw(""What a beautiful day!"", SUN, 27);
  draw(""The sun's come out!"", SUN_CLOUD, 19);
  draw(""It's raining cats and dogs."", RAIN, 8);
  draw(""That sounds like thunder."", THUNDER, 12);
  draw(""It's stopped raining"", CLOUD, 15);
  
  
  
}

",16236,True,4564.417100698121,median
"////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You 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 mx.controls
{

import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.TextEvent;
import mx.collections.ArrayCollection;
import mx.collections.CursorBookmark;
import mx.collections.ICollectionView;
import mx.collections.IList;
import mx.collections.IViewCursor;
import mx.collections.ListCollectionView;
import mx.collections.XMLListCollection;
import mx.core.EdgeMetrics;
import mx.core.FlexVersion;
import mx.core.IFlexDisplayObject;
import mx.core.IIMESupport;
import mx.core.IRectangularBorder;
import mx.core.ITextInput;
import mx.core.IUITextField;
import mx.core.UIComponent;
import mx.core.UITextField;
import mx.core.mx_internal;
import mx.events.CollectionEvent;
import mx.events.CollectionEventKind;
import mx.events.FlexEvent;
import mx.managers.IFocusManager;
import mx.managers.IFocusManagerComponent;
import mx.styles.ISimpleStyleClient;
import mx.styles.StyleProxy;
import mx.utils.UIDUtil;


use namespace mx_internal;

/**
 *  The alpha of the content background for this component.
 * 
 *  @langversion 3.0
 *  @playerversion Flash 10
 *  @playerversion AIR 1.5
 *  @productversion Flex 4
 */
[Style(name=""contentBackgroundAlpha"", type=""Number"", inherit=""yes"", theme=""spark"")]

/**
 *  Color of the content area of the component.
 *   
 *  @default 0xFFFFFF
 *  
 *  @langversion 3.0
 *  @playerversion Flash 10
 *  @playerversion AIR 1.5
 *  @productversion Flex 4
 */ 
[Style(name=""contentBackgroundColor"", type=""uint"", format=""Color"", inherit=""yes"", theme=""spark"")]

/**
 *  Color of focus ring when the component is in focus
 *   
 *  @default 0x70B2EE
 *  
 *  @langversion 3.0
 *  @playerversion Flash 10
 *  @playerversion AIR 1.5
 *  @productversion Flex 4
 */ 
[Style(name=""focusColor"", type=""uint"", format=""Color"", inherit=""yes"", theme=""spark"")]

/**
 *  Color of any symbol of a component. Examples include the check mark of a CheckBox or
 *  the arrow of a ScrollBar button.
 *   
 *  @default 0x000000
 * 
 *  @langversion 3.0
 *  @playerversion Flash 10
 *  @playerversion AIR 1.5
 *  @productversion Flex 4
 */ 
[Style(name=""symbolColor"", type=""uint"", format=""Color"", inherit=""yes"", theme=""spark"")]

/**
 *  Name of the class to use as the default skin for the background and border. 
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""skin"", type=""Class"", inherit=""no"", states="" up, over, down, disabled,  editableUp, editableOver, editableDown, editableDisabled"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the mouse is not over the control.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""upSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the mouse is over the control.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  For the ColorPicker class, the default value is the ColorPickerSkin class.
 *  For the DateField class, the default value is the ScrollArrowDownSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""overSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the user holds down the mouse button.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  For the ColorPicker class, the default value is the ColorPickerSkin class.
 *  For the DateField class, the default value is the ScrollArrowDownSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""downSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the control is disabled.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  For the ColorPicker class, the default value is the ColorPickerSkin class.
 *  For the DateField class, the default value is the ScrollArrowDownSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""disabledSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the <code>editable</code>
 *  property is <code>true</code>. This skin is only used by the ComboBox class.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""editableSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the mouse is not over the control, and the <code>editable</code>
 *  property is <code>true</code>. This skin is only used by the ComboBox class.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""editableUpSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the mouse is over the control, and the <code>editable</code>
 *  property is <code>true</code>. This skin is only used by the ComboBox class.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""editableOverSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the user holds down the mouse button, and the <code>editable</code>
 *  property is <code>true</code>. This skin is only used by the ComboBox class.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""editableDownSkin"", type=""Class"", inherit=""no"")]

/**
 *  Name of the class to use as the skin for the background and border
 *  when the control is disabled, and the <code>editable</code>
 *  property is <code>true</code>. This skin is only used by the ComboBox class.
 *  For the ComboBase class, there is no default value.
 *  For the ComboBox class, the default value is the ComboBoxArrowSkin class.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""editableDisabledSkin"", type=""Class"", inherit=""no"")]

/**
 *  The class implementing ITextInput that is used by this component
 *  to input text.
 *
 *  <p>It can be set to either the mx.core.TextInput class
 *  (to use the classic Halo TextInput control)
 *  or the mx.controls.MXFTETextInput class
 *  (to use the Spark TextInput component based on the Text Layout Framework 
 *  to get improved text rendering, including bidirectional layout).</p>
 *
 *  @default mx.controls.TextInput
 *  
 *  @langversion 3.0
 *  @playerversion Flash 10
 *  @playerversion AIR 1.5
 *  @productversion Flex 4
 */
[Style(name=""textInputClass"", type=""Class"", inherit=""no"")]

/**
 *  The style declaration for the internal TextInput subcomponent 
 *  that displays the current selection. 
 *  If no value is specified, then the TextInput subcomponent uses 
 *  the default text styles defined by the ComboBase class.
 *
 *  @default """"
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
[Style(name=""textInputStyleName"", type=""String"", inherit=""no"")]
//--------------------------------------
//  Other metadata
//--------------------------------------

[AccessibilityClass(implementation=""mx.accessibility.ComboBaseAccImpl"")]

/**
 *  The ComboBase class is the base class for controls that display text in a 
 *  text field and have a button that causes a drop-down list to appear where 
 *  the user can choose which text to display.
 *  The ComboBase class is not used directly as an MXML tag.
 *
 *  @mxml
 *
 *  <p>The <code>&lt;mx:ComboBase&gt;</code> tag inherits all the tag attributes
 *  of its superclass, and adds the following tag attributes:</p>
 *
 *  <pre>
 *  &lt;<i>mx:tagname</i>
 *    <b>Properties</b>
 *    dataProvider=""null""
 *    editable=""false|true""
 *    imeMode=""null""
 *    restrict=""null""
 *    selectedIndex=""-1""
 *    selectedItem=""null""
 *    text=""""
 *    &nbsp;
 *    <b>Styles</b>
 *    disabledSkin=""<i>Depends on class</i>""
 *    downSkin=""<i>Depends on class</i>""
 *    editableDisabledSkin=""<i>Depends on class</i>""
 *    editableDownSkin=""<i>Depends on class</i>""
 *    editableOverSkin=""<i>Depends on class</i>""
 *    editableUpSkin=""<i>Depends on class</i>""
 *    overSkin=""<i>Depends on class</i>""
 *    textInputStyleName="""" 
 *    upSkin=""<i>Depends on class</i>""
 *
 *  /&gt;
 *  </pre>
 *
 *  @see mx.controls.Button
 *  @see mx.controls.TextInput
 *  @see mx.collections.ICollectionView
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
public class ComboBase extends UIComponent implements IIMESupport, IFocusManagerComponent
{
    include ""../core/Version.as"";

    //--------------------------------------------------------------------------
    //
    //  Class mixins
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     *  Placeholder for mixin by ComboBaseAccImpl.
     */
    mx_internal static var createAccessibilityImplementation:Function;

    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------

    /**
     *  Constructor.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function ComboBase()
    {
        super();

        tabEnabled = true;
        tabFocusEnabled = true;
    }

    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------

    /**
     *  The ICollectionView of items this component displays.  
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected var collection:ICollectionView;

    /**
     *  The main IViewCursor used to fetch items from the
     *  dataProvider and pass the items to the renderers.
     *  At the end of any sequence of code, it must always be positioned
     *  at the topmost visible item on screen.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected var iterator:IViewCursor;

    /**
     *  @private
     *  A separate IViewCursor used to find indices of items and other things.
     *  The collectionIterator can be at any place within the set of items.
     */
    mx_internal var collectionIterator:IViewCursor;

    /**
     *  @private
     *  The internal object that draws the border.
     */
    mx_internal var border:IFlexDisplayObject;

    /**
     *  @private
     *  The internal Button property that causes the drop-down list to appear.
     */
    mx_internal var downArrowButton:Button;

    /**
     *  @private
     */
    mx_internal var wrapDownArrowButton:Boolean = true;

    /**
     *  @private
     */
    mx_internal var useFullDropdownSkin:Boolean = false;

    /**
     *  @private
     */
    private var selectedUID:String;

    /**
     *  @private
     *  A flag indicating that selection has changed
     */
    mx_internal var selectionChanged:Boolean = false;

    /**
     *  @private
     *  A flag indicating that selectedIndex has changed
     */
    mx_internal var selectedIndexChanged:Boolean = false;

    /**
     *  @private
     *  A flag indicating that selectedItem has changed
     */
    mx_internal var selectedItemChanged:Boolean = false;

    /**
     *  @private
     *  Stores the old value of the borderStyle style
     */
    mx_internal var oldBorderStyle:String;

    //--------------------------------------------------------------------------
    //
    //  Overridden properties
    //
    //--------------------------------------------------------------------------

    //----------------------------------
    //  baselinePosition
    //----------------------------------

    /**
     *  @private
     *  The baselinePosition of a ComboBase is calculated for its TextInput.
     */
    override public function get baselinePosition():Number
    {
        if (!validateBaselinePosition())
            return NaN;

        return textInput.y  + textInput.baselinePosition;
    }

    //----------------------------------
    //  enabled
    //----------------------------------

    /**
     *  @private
     *  Storage for enabled property.
     */
    private var _enabled:Boolean = false;

    /**
     *  @private
     */
    private var enabledChanged:Boolean = false;

    [Inspectable(category=""General"", enumeration=""true,false"", defaultValue=""true"")]

    /**
     *  @private
     */
    override public function set enabled(value:Boolean):void
    {
        super.enabled = value;
        _enabled = value;

        enabledChanged = true;
        invalidateProperties();
    }

    //--------------------------------------------------------------------------
    //
    //  Properties
    //
    //--------------------------------------------------------------------------

     //----------------------------------
    //  arrowButtonStyleFilters
    //----------------------------------
    
    /**
     *  Set of styles to pass from the ComboBase to the down arrow button
     *  @see mx.styles.StyleProxy
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */ 
    protected function get arrowButtonStyleFilters():Object
    {
        return null;
    }
    //----------------------------------
    //  borderMetrics
    //----------------------------------

    /**
     *  Returns an EdgeMetrics object that has four properties:
     *  <code>left</code>, <code>top</code>, <code>right</code>,
     *  and <code>bottom</code>.
     *  The value of each property is equal to the thickness of the
     *  corresponding side of the border, expressed in pixels.
     *
     *  @return EdgeMetrics object with the left, right, top,
     *  and bottom properties.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get borderMetrics():EdgeMetrics
    {
        if (border && border is IRectangularBorder)
            return IRectangularBorder(border).borderMetrics;

        return EdgeMetrics.EMPTY;
    }

    //----------------------------------
    //  dataProvider
    //----------------------------------

    [Bindable(""collectionChange"")]
    [Inspectable(category=""Data"")]

    /**
     *  The set of items this component displays. This property is of type
     *  Object because the derived classes can handle a variety of data
     *  types such as Arrays, XML, ICollectionViews, and other classes.  All
     *  are converted into an ICollectionView and that ICollectionView is
     *  returned if you get the value of this property; you will not get the
     *  value you set if it was not an ICollectionView.
     *
     *  <p>Setting this property will adjust the <code>selectedIndex</code>
     *  property (and therefore the <code>selectedItem</code> property) if 
     *  the <code>selectedIndex</code> property has not otherwise been set. 
     *  If there is no <code>prompt</code> property, the <code>selectedIndex</code>
     *  property will be set to 0; otherwise it will remain at -1,
     *  the index used for the prompt string.  
     *  If the <code>selectedIndex</code> property has been set and
     *  it is out of range of the new data provider, unexpected behavior is
     *  likely to occur.</p>
     * 
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get dataProvider():Object
    {
        return collection;
    }

    /**
     *  @private
     */
    public function set dataProvider(value:Object):void
    {
        if (value is Array)
        {
            collection = new ArrayCollection(value as Array);
        }
        else if (value is ICollectionView)
        {
            collection = ICollectionView(value);
        }
        else if (value is IList)
        {
            collection = new ListCollectionView(IList(value));
        }
        else if (value is XMLList)
        {
            collection = new XMLListCollection(value as XMLList);
        }
        else
        {
            // convert it to an array containing this one item
            var tmp:Array = [value];
            collection = new ArrayCollection(tmp);
        }
        // get an iterator for the displaying rows.  The CollectionView's
        // main iterator is left unchanged so folks can use old DataSelector
        // methods if they want to
        iterator = collection.createCursor();
        collectionIterator = collection.createCursor(); //IViewCursor(collection);

        // trace(""ListBase added change listener"");
        // weak listeners to collections and dataproviders
        collection.addEventListener(CollectionEvent.COLLECTION_CHANGE, collectionChangeHandler, false, 0, true);

        var event:CollectionEvent =
            new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
        event.kind = CollectionEventKind.RESET;
        collectionChangeHandler(event);
        dispatchEvent(event);

        invalidateSize();
        invalidateDisplayList();
    }

    //----------------------------------
    //  editable
    //----------------------------------

    /**
     *  @private
     *  Storage for editable property.
     */
    private var _editable:Boolean = false;

    /**
     *  @private
     */
    mx_internal var editableChanged:Boolean = true;

    [Bindable(""editableChanged"")]
    [Inspectable(category=""General"", defaultValue=""false"")]

    /**
     *  A flag that indicates whether the control is editable, 
     *  which lets the user directly type entries that are not specified 
     *  in the dataProvider, or not editable, which requires the user select
     *  from the items in the dataProvider.
     *
     *  <p>If <code>true</code> keyboard input will be entered in the
     *  editable text field; otherwise it will be used as shortcuts to
     *  select items in the dataProvider.</p>
     *
     *  @default false.
     *  This property is ignored by the DateField control.
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get editable():Boolean
    {
        return _editable;
    }

    /**
     *  @private
     */
    public function set editable(value:Boolean):void
    {
        _editable = value;
        editableChanged = true;

        invalidateProperties();

        dispatchEvent(new Event(""editableChanged""));
    }

    //----------------------------------
    //  enableIME
    //----------------------------------

    /**
     *  A flag that indicates whether the IME should
     *  be enabled when the component receives focus. 
     *
     *  @langversion 3.0
     *  @playerversion Flash 10
     *  @playerversion AIR 1.5
     *  @productversion Flex 4
     */
    public function get enableIME():Boolean
    {
        return editable;
    }

    //----------------------------------
    //  imeMode
    //----------------------------------

    /**
     *  @private
     */
    private var _imeMode:String = null;

    /**
     *  @copy mx.controls.TextInput#imeMode
     * 
     *  @default null
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     **/
    public function get imeMode():String
    {
        return _imeMode;
    }

    /**
     *  @private
     */
    public function set imeMode(value:String):void
    {
        _imeMode = value;

        if (textInput)
            textInput.imeMode = _imeMode;
    }

    //----------------------------------
    //  restrict
    //----------------------------------

    /**
     *  @private
     *  Storage for restrict property.
     */
    private var _restrict:String;

    [Bindable(""restrictChanged"")]
    [Inspectable(category=""Other"")]

    /**
     *  Set of characters that a user can or cannot enter into the text field.
     * 
     *  @default null
     *
     *  @see flash.text.TextField#restrict
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get restrict():String
    {
        return _restrict;
    }

    /**
     *  @private
     */
    public function set restrict(value:String):void
    {
        _restrict = value;

        invalidateProperties();

        dispatchEvent(new Event(""restrictChanged""));
    }

    //----------------------------------
    //  selectedIndex
    //----------------------------------

    private var _selectedIndex:int = -1;

    [Bindable(""change"")]
    [Bindable(""valueCommit"")]
    [Inspectable(category=""General"", defaultValue=""-1"")]

    /**
     *  The index in the data provider of the selected item.
     *  If there is a <code>prompt</code> property, the <code>selectedIndex</code>
     *  value can be set to -1 to show the prompt.
     *  If there is no <code>prompt</code>, property then <code>selectedIndex</code>
     *  will be set to 0 once a <code>dataProvider</code> is set.
     *
     *  <p>If the ComboBox control is editable, the <code>selectedIndex</code>
     *  property is -1 if the user types any text
     *  into the text field.</p>
     *
     *  <p>Unlike many other Flex properties that are invalidating (setting
     *  them does not have an immediate effect), the <code>selectedIndex</code> and
     *  <code>selectedItem</code> properties are synchronous; setting one immediately 
     *  affects the other.</p>
     *
     *  @default -1
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectedIndex():int
    {
        return _selectedIndex;
    }

    /**
     *  @private
     */
    public function set selectedIndex(value:int):void
    {
        _selectedIndex = value;
        if (value == -1)
        {
            _selectedItem = null;
            selectedUID = null;
        }

        //2 code paths: one for before collection, one after
        if (!collection || collection.length == 0)
        {
            selectedIndexChanged = true;
        }
        else
        {
            if (value != -1)
            {
                value = Math.min(value, collection.length - 1);
                var bookmark:CursorBookmark = iterator.bookmark;
                var len:int = value;
                iterator.seek(CursorBookmark.FIRST, len);
                var data:Object = iterator.current;
                var uid:String = itemToUID(data);
                iterator.seek(bookmark, 0);
                _selectedIndex = value;
                _selectedItem = data;
                selectedUID = uid;
            }
        }

        selectionChanged = true;

        invalidateDisplayList();

        dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
    }


    //----------------------------------
    //  selectedItem
    //----------------------------------

    /**
     *  @private
     *  Storage for the selectedItem property.
     */
    private var _selectedItem:Object;

    [Bindable(""change"")]
    [Bindable(""valueCommit"")]
    [Inspectable(category=""General"", defaultValue=""null"")]

    /**
     *  The item in the data provider at the selectedIndex.
     *
     *  <p>If the data is an object or class instance, modifying
     *  properties in the object or instance modifies the 
     *  <code>dataProvider</code> object but may not update the views  
     *  unless the instance is Bindable or implements IPropertyChangeNotifier
     *  or a call to dataProvider.itemUpdated() occurs.</p>
     *
     *  Setting the <code>selectedItem</code> property causes the
     *  ComboBox control to select that item (display it in the text field and
     *  set the <code>selectedIndex</code>) if it exists in the data provider.
     *  If the ComboBox control is editable, the <code>selectedItem</code>
     *  property is <code>null</code> if the user types any text
     *  into the text field.
     *
     *  <p>Unlike many other Flex properties that are invalidating (setting
     *  them does not have an immediate effect), <code>selectedIndex</code> and
     *  <code>selectedItem</code> are synchronous; setting one immediately 
     *  affects the other.</p>
     *
     *  @default null;
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get selectedItem():Object
    {
        return _selectedItem;
    }

    /**
     *  @private
     */
    public function set selectedItem(data:Object):void
    {
        setSelectedItem(data);
    }

    /**
     *  @private
     */
    private function setSelectedItem(data:Object, clearFirst:Boolean = true):void
    {
        //2 code paths: one for before collection, one after
        if (!collection || collection.length == 0)
        {
           _selectedItem = data;
            selectedItemChanged = true;
            invalidateDisplayList();
            return;
        }

        var found:Boolean = false;
        var listCursor:IViewCursor = collection.createCursor();
        var i:int = 0;
        do
        {
            if (data == listCursor.current)
            {
                _selectedIndex = i;
                _selectedItem = data;
                selectedUID = itemToUID(data);
                selectionChanged = true;
                found = true;
                break;
            }
            i++;
        }
        while (listCursor.moveNext());

        if (!found)
        {
            selectedIndex = -1;
            _selectedItem = null;
            selectedUID = null;
        }

        invalidateDisplayList();
    }

    //----------------------------------
    //  text
    //----------------------------------

    /**
     *  @private
     *  Storage for the text property.
     */
    private var _text:String = """";

    /**
     *  @private
     */
    mx_internal var textChanged:Boolean;

    [Bindable(""collectionChange"")]
    [Bindable(""valueCommit"")]
    [Inspectable(category=""General"", defaultValue="""")]
    [NonCommittingChangeEvent(""change"")]

    /**
     *  Contents of the text field.  If the control is non-editable
     *  setting this property has no effect. If the control is editable, 
     *  setting this property sets the contents of the text field.
     *
     *  @default """"
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get text():String
    {
        return _text;
    }

    /**
     *  @private
     */
    public function set text(value:String):void
    {
        _text = value;
        textChanged = true;

        invalidateProperties();

        dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
    }

    //----------------------------------
    //  textInput
    //----------------------------------

    /**
     *  The internal TextInput subcomponent that displays
     *  the current selection.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected var textInput:ITextInput;


    //----------------------------------
    //  textInputStyleFilters
    //----------------------------------

    /**
     *  The set of styles to pass from the ComboBase to the text input. 
     *  These styles are ignored if you set 
     *  the <code>textInputStyleName</code> style property.
     *  @see mx.styles.StyleProxy
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get textInputStyleFilters():Object 
    {
        return _textInputStyleFilters;
    }
    
    private static var _textInputStyleFilters:Object =
    {
        ""backgroundAlpha"" : ""backgroundAlpha"",
        ""backgroundColor"" : ""backgroundColor"",
        ""backgroundImage"" : ""backgroundImage"",
        ""backgroundDisabledColor"" : ""backgroundDisabledColor"",
        ""backgroundSize"" : ""backgroundSize"",
        ""borderAlpha"" : ""borderAlpha"", 
        ""borderColor"" : ""borderColor"",
        ""borderSides"" : ""borderSides"", 
        ""borderStyle"" : ""borderStyle"",
        ""borderThickness"" : ""borderThickness"",
        ""dropShadowColor"" : ""dropShadowColor"",
        ""dropShadowEnabled"" : ""dropShadowEnabled"",
        ""embedFonts"" : ""embedFonts"",
        ""focusAlpha"" : ""focusAlpha"",
        ""focusBlendMode"" : ""focusBlendMode"",
        ""focusRoundedCorners"" : ""focusRoundedCorners"", 
        ""focusThickness"" : ""focusThickness"",
        ""leading"" : ""leading"",
        ""paddingLeft"" : ""paddingLeft"", 
        ""paddingRight"" : ""paddingRight"",
        ""shadowDirection"" : ""shadowDirection"",
        ""shadowDistance"" : ""shadowDistance"",
        ""textDecoration"" : ""textDecoration""
     };

    //----------------------------------
    //  value
    //----------------------------------

    [Bindable(""change"")]
    [Bindable(""valueCommit"")]

    /**
     *  The value of the selected item. If the item is a Number or String,
     *  the value is the item. If the item is an object, the value is
     *  the <code>data</code> property, if it exists, or the <code>label</code>
     *  property, if it exists.
     *
     *  <p><strong>Note:</strong> Using the <code>selectedItem</code> property 
     *  is often preferable to using this property. The <code>value</code>
     *  property exists for backward compatibility with older applications.</p>
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get value():Object
    {
        if (_editable)
            return text;

        var item:Object = selectedItem;

        if (item == null || typeof(item) != ""object"")
            return item;

        // Note: the explicit comparison with null is important, because otherwise when
        // the data is zero, the label will be returned.  See bug 183294 for an example.
        return item.data != null ? item.data : item.label;
    }

    //--------------------------------------------------------------------------
    //
    //  Overridden methods
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     */
    override protected function initializeAccessibility():void
    {
        if (ComboBase.createAccessibilityImplementation != null)
            ComboBase.createAccessibilityImplementation(this);
    }

    /**
     *  @private
     */
    override protected function createChildren():void
    {
        super.createChildren();

        // Create the border first, in the back.
        if (!border)
        {
            var borderClass:Class = getStyle(""borderSkin"");

            if (borderClass)
            {
                border = new borderClass();

                if (border is IFocusManagerComponent)
                    IFocusManagerComponent(border).focusEnabled = false;

                if (border is ISimpleStyleClient)
                    ISimpleStyleClient(border).styleName = this;

                addChild(DisplayObject(border));
                
                if (FlexVersion.compatibilityVersion >= FlexVersion.VERSION_4_0)
                    border.visible = false;
            }
        }

        // Next, create the downArrowButton before creating the textInput,
        // because it can be as large as the entire control.
        if (!downArrowButton)
        {
            downArrowButton = new Button();
            downArrowButton.styleName = new StyleProxy(this, arrowButtonStyleFilters);
            downArrowButton.focusEnabled = false;
            downArrowButton.tabEnabled = false;
            
            addChild(downArrowButton);

            downArrowButton.addEventListener(FlexEvent.BUTTON_DOWN,
                                             downArrowButton_buttonDownHandler);

        }

        // Create the textInput on top.
        if (!textInput)
        {
            var textInputStyleName:Object = getStyle(""textInputStyleName"");
            if (!textInputStyleName)
                textInputStyleName = new StyleProxy(this, textInputStyleFilters);
            
            // Mechanism to use MXFTETextInput. 
            var textInputClass:Class = getStyle(""textInputClass"");            
            if (!textInputClass || 
                FlexVersion.compatibilityVersion < FlexVersion.VERSION_4_0)
            {
                textInput = new TextInput();
            }
            else
            {
                textInput = new textInputClass();
            }

            textInput.editable = _editable;
            editableChanged = true;
            // Don't show ESC characters in the text field.
            textInput.restrict = ""^\\u001b"";
            textInput.focusEnabled = false;
            textInput.mouseEnabled = textInput.mouseChildren = _editable;
            textInput.imeMode = _imeMode;
            textInput.styleName = textInputStyleName;

            textInput.addEventListener(Event.CHANGE, textInput_changeHandler);
            textInput.addEventListener(FlexEvent.ENTER, textInput_enterHandler);
            textInput.addEventListener(FocusEvent.FOCUS_IN, focusInHandler);
            textInput.addEventListener(FocusEvent.FOCUS_OUT, focusOutHandler);
            textInput.addEventListener(FlexEvent.VALUE_COMMIT,
                                       textInput_valueCommitHandler);

            addChild(DisplayObject(textInput));

            textInput.move(0, 0);

            textInput.parentDrawsFocus = true;
        }
    }

    /**
     *  @private
     */
    override public function styleChanged(styleProp:String):void
    {
        if (downArrowButton)
            downArrowButton.styleChanged(styleProp);

        if (textInput)
            textInput.styleChanged(styleProp);

        if (border && border is ISimpleStyleClient)
            ISimpleStyleClient(border).styleChanged(styleProp);

        super.styleChanged(styleProp);
    }

    /**
     *  @private
     */
    override protected function commitProperties():void
    {
        super.commitProperties();

        // A TextField interprets restrict="""" as meaning
        // don't allow any characters, and restrict = null
        // as meaning allow all characters.
        // The former is useless (the TextField should be disabled
        // instead) and the latter is useful, but MXML doesn't
        // have a way to specify restrict = null. So Flex changes
        // the semantics of restrict="""" to mean allow all characters.
        textInput.restrict = _restrict;

        if (textChanged)
        {
            textInput.text = _text;
            textChanged = false;
        }

        if (enabledChanged)
        {
            textInput.enabled = _enabled;
            editableChanged = true;
            downArrowButton.enabled = _enabled;
            enabledChanged = false;
        }

        if (editableChanged)
        {
            editableChanged = false;
            var e:Boolean = _editable;
            
            if (wrapDownArrowButton == false)
            {
                if (e)
                {
                    if (oldBorderStyle)
                        setStyle(""borderStyle"", oldBorderStyle);
                }
                else
                {
                    oldBorderStyle = getStyle(""borderStyle"");
                    setStyle(""borderStyle"", ""comboNonEdit"");
                }
            }
            
            // Swap the button skins if we have different skins for editable and
            // non-editable states.
            if (useFullDropdownSkin)
            {
                if (e && getStyle(""editableSkin"") != null)
                    downArrowButton.skinName = ""editableSkin"";
                else
                    downArrowButton.skinName = ""skin"";
                downArrowButton.upSkinName = e ? ""editableUpSkin"" : ""upSkin"";
                downArrowButton.overSkinName = e ? ""editableOverSkin"" : ""overSkin"";
                downArrowButton.downSkinName = e ? ""editableDownSkin"" : ""downSkin"";
                downArrowButton.disabledSkinName = e ? ""editableDisabledSkin"" : ""disabledSkin"";
                downArrowButton.changeSkins();
                downArrowButton.invalidateDisplayList();
            }
            
            if (textInput)
            {
                textInput.editable = e;
                textInput.selectable = e;
                if (e)
                {
                    textInput.removeEventListener(MouseEvent.MOUSE_DOWN,
                                                  textInput_mouseEventHandler);
                    textInput.removeEventListener(MouseEvent.MOUSE_UP,
                                                  textInput_mouseEventHandler);
                    textInput.removeEventListener(MouseEvent.ROLL_OVER,
                                                  textInput_mouseEventHandler);
                    textInput.removeEventListener(MouseEvent.ROLL_OUT,
                                                  textInput_mouseEventHandler);
                    textInput.addEventListener(KeyboardEvent.KEY_DOWN,
                                               keyDownHandler);
                }
                else
                {
                    // Trap all mouse actions on the textfield and feed them to the button
                    textInput.addEventListener(MouseEvent.MOUSE_DOWN,
                                               textInput_mouseEventHandler);
                    textInput.addEventListener(MouseEvent.MOUSE_UP,
                                              textInput_mouseEventHandler);
                    textInput.addEventListener(MouseEvent.ROLL_OVER,
                                               textInput_mouseEventHandler);
                    textInput.addEventListener(MouseEvent.ROLL_OUT,
                                               textInput_mouseEventHandler);
                    textInput.removeEventListener(KeyboardEvent.KEY_DOWN,
                                                  keyDownHandler);
                }
            }
        }
    }

    /**
     *  Determines the <code>measuredWidth</code> and
     *  <code>measuredHeight</code> properties of the control.
     *  The measured width is the width of the widest text
     *  in the <code>dataProvider</code>
     *  plus the width of the drop-down button.
     *  The measured height is the larger of either the button or the text.
     *  If no data provider has been set or there are no items
     *  in the data provider, the <code>measuredWidth</code> property is set to
     *  <code>UIComponent.DEFAULT_MEASURED_WIDTH</code> and the 
     *  <code>measuredHeight</code> property is set
     *  to <code>UIComponent.DEFAULT_MEASURED_HEIGHT</code>.
     * 
     *  @see mx.core.UIComponent#measure()
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    override protected function measure():void
    {
        super.measure();

        var buttonWidth:Number = getStyle(""arrowButtonWidth"");
        var buttonHeight:Number = downArrowButton.getExplicitOrMeasuredHeight();

        // Text fields have 4 pixels of white space added to each side
        // by the player, so fudge this amount.
        // If we don't have any data, measure a single space char for defaults
        if (collection && collection.length > 0)
        {
            var prefSize:Object = calculatePreferredSizeFromData(collection.length);

            var bm:EdgeMetrics = borderMetrics;

            var textWidth:Number = prefSize.width + bm.left + bm.right + 8;
            var textHeight:Number = prefSize.height + bm.top + bm.bottom 
                        + UITextField.TEXT_HEIGHT_PADDING;

            measuredMinWidth = measuredWidth = textWidth + buttonWidth;
            measuredMinHeight = measuredHeight = Math.max(textHeight, buttonHeight);
        }
        else
        {
            measuredMinWidth = DEFAULT_MEASURED_MIN_WIDTH;
            measuredWidth = DEFAULT_MEASURED_WIDTH;
            measuredMinHeight = DEFAULT_MEASURED_MIN_HEIGHT;
            measuredHeight = DEFAULT_MEASURED_HEIGHT;
        }
        
        // Add in the paddingTop and paddingBottom values
        var padding:Number = getStyle(""paddingTop"") + getStyle(""paddingBottom"");
        measuredMinHeight += padding;
        measuredHeight += padding;
    }

    /**
     *  Sizes and positions the internal components in the given width
     *  and height.  The drop-down button is placed all the way to the right
     *  and the text field fills the remaining area.
     * 
     *  @param unscaledWidth Specifies the width of the component, in pixels,
     *  in the component's coordinates, regardless of the value of the
     *  <code>scaleX</code> property of the component.
     *
     *  @param unscaledHeight Specifies the height of the component, in pixels,
     *  in the component's coordinates, regardless of the value of the
     *  <code>scaleY</code> property of the component.
     * 
     *  @see mx.core.UIComponent#updateDisplayList()
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    override protected function updateDisplayList(unscaledWidth:Number,
                                                  unscaledHeight:Number):void
    {
        super.updateDisplayList(unscaledWidth, unscaledHeight);

        var w:Number = unscaledWidth;
        var h:Number = unscaledHeight;

        var arrowWidth:Number = getStyle(""arrowButtonWidth"");
        var textInputHeight:Number = textInput.getExplicitOrMeasuredHeight();

        if (isNaN(arrowWidth))
            arrowWidth = 0;

        if (wrapDownArrowButton)
        {
            var vm:EdgeMetrics = borderMetrics;
            var wh:Number = h - vm.top - vm.bottom;
            downArrowButton.setActualSize(wh, wh);
            downArrowButton.move(w - arrowWidth - vm.right, vm.top);
            if (border)
                border.setActualSize(w, h);
            textInput.setActualSize(w - arrowWidth, textInputHeight);
        }
        else
        {
            if (!_editable && useFullDropdownSkin)
            {
                var paddingTop:Number = getStyle(""paddingTop"");
                var paddingBottom:Number = getStyle(""paddingBottom"");
                
                downArrowButton.move(0, 0);
                if (border)
                    border.setActualSize(w, h);
                textInput.setActualSize(w - arrowWidth, textInputHeight);
                textInput.showBorderAndBackground(false);
                textInput.move(textInput.x, ((h - textInputHeight - paddingTop - paddingBottom) / 2) + paddingTop);
                downArrowButton.setActualSize(unscaledWidth, unscaledHeight);
            }
            else
            {
                downArrowButton.move(w - arrowWidth, 0);
                if (border)
                    border.setActualSize(w - arrowWidth, h);
                textInput.setActualSize(w - arrowWidth, h);
                downArrowButton.setActualSize(arrowWidth, unscaledHeight);
                textInput.showBorderAndBackground(true);
            }
        }
        
        if (selectedItemChanged)
        {
            selectedItem = selectedItem;
            selectedItemChanged = false;
            selectedIndexChanged = false;
        }

        if (selectedIndexChanged)
        {
            selectedIndex = selectedIndex;
            selectedIndexChanged = false;
        }   
    }

    /**
     *  @private
     */
    override public function setFocus():void
    {
        if (textInput && _editable)
            textInput.setFocus();
        else
            super.setFocus();
    }

    /**
     *  @private
     */
    override protected function isOurFocus(target:DisplayObject):Boolean
    {
        return target == textInput || super.isOurFocus(target);
    }

    //--------------------------------------------------------------------------
    //
    //  Methods
    //
    //--------------------------------------------------------------------------

    /**
     *  Determines default values of the height and width to use for the 
     *  entries in the drop-down list. 
     *  Each subclass of ComboBase must implement this method and return 
     *  an Object containing two properties: <code>width</code> and 
     *  <code>height</code>.
     *
     *  @param numItems The number of items to check to determine the size.
     *
     *  @return An Object with <code>width</code> and <code>height</code> 
     *  properties.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function calculatePreferredSizeFromData(numItems:int):Object
    {
        return null;
    }

    /**
     *  Determines the UID for a dataProvider item.
     *  Every dataProvider item must have or will be assigned a unique
     *  identifier (UID).
     *
     *  @param data A dataProvider item.
     *
     *  @return A unique identifier.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function itemToUID(data:Object):String
    {
        if (!data)
            return ""null"";

        return UIDUtil.getUID(data);
    }

    //--------------------------------------------------------------------------
    //
    //  Overridden event handlers
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     */
    override protected function focusInHandler(event:FocusEvent):void
    {
        super.focusInHandler(event);
    }

    /**
     *  @private
     */
    override protected function focusOutHandler(event:FocusEvent):void
    {
        super.focusOutHandler(event);

        var fm:IFocusManager = focusManager;

        if (fm && event.target == this)
            fm.defaultButtonEnabled = true;

        if (_editable)
            dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
    }

    //--------------------------------------------------------------------------
    //
    //  Event handlers
    //
    //--------------------------------------------------------------------------

    /**
     *  Responds to changes to the data provider.  The component will adjust
     *  the <code>selectedIndex</code> property if items are added or removed 
     *  before the component's selected item.
     *
     *  @param event The CollectionEvent dispatched from the collection.
     *
     *  @see mx.events.CollectionEvent
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function collectionChangeHandler(event:Event):void
    {
        if (event is CollectionEvent)
        {
            var requiresValueCommit:Boolean = false;

            var len:Number;

            var ind:Object;

            var ce:CollectionEvent = CollectionEvent(event);
            if (ce.kind == CollectionEventKind.ADD)
            {
                if (selectedIndex >= ce.location)
                    _selectedIndex++;
            }
            if (ce.kind == CollectionEventKind.REMOVE)
            {
                for (var i:int = 0; i < ce.items.length; i++)
                {
                    var uid:String = itemToUID(ce.items[i]);
                    if (selectedUID == uid)
                    {
                        selectionChanged = true;
                    }
                }
                if (selectionChanged)
                {
                    if (_selectedIndex >= collection.length)
                        _selectedIndex = collection.length - 1;

                    selectedIndexChanged = true;
                    requiresValueCommit = true;
                    invalidateDisplayList();
                }
                else if (selectedIndex >= ce.location)
                {
                    _selectedIndex--;
                    selectedIndexChanged = true;
                    requiresValueCommit = true;
                    invalidateDisplayList();
                }
            
            }
            if (ce.kind == CollectionEventKind.REFRESH)
            {
                selectedItemChanged = true;
                // Sorting always changes the selection array
                requiresValueCommit = true;
            }

            invalidateDisplayList();

            if (requiresValueCommit)
                dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
        }
    }

    /**
     *  @private
     *  Forward an event to the down arrow button.
     */
    private function textInput_mouseEventHandler(event:Event):void
    {
        downArrowButton.dispatchEvent(event);
    }

    /**
     *  Handles changes to the TextInput that serves as the editable
     *  text field in the component.  The method sets 
     *  <code>selectedIndex</code> to -1 (and therefore 
     *  <code>selectedItem</code> to <code>null</code>).
     * 
     *  @param event The event that is triggered each time the text in the control changes.     
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function textInput_changeHandler(event:Event):void
    {
        // update _text as the user types
        _text = textInput.text;
        if (_selectedIndex != -1)
        {
            _selectedIndex = -1;
            _selectedItem = null;
            selectedUID = null;
        }
    }

    /**
     *  @private
     *  valueCommit handler for the textInput
     */
    private function textInput_valueCommitHandler(event:FlexEvent):void
    {
        // update _text if textInput.text is changed programatically
        _text = textInput.text;
        dispatchEvent(event);
    }

    /**
     *  @private
     */
    private function textInput_enterHandler(event:FlexEvent):void
    {
        dispatchEvent(event);
        dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
    }

    /**
     *  Performs some action when the drop-down button is pressed.  This is
     *  an abstract base class implementation, so it has no effect and is
     *  overridden by the subclasses.
     * 
     *  @param event The event that is triggered when the drop-down button is pressed.     
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function downArrowButton_buttonDownHandler(event:FlexEvent):void
    {
        // overridden by subclasses
    }

    /**
     *  @private
     */
    mx_internal function getTextInput():ITextInput
    {
        return textInput;
    }

    /**
     *  @private
     */
    mx_internal function get ComboDownArrowButton():Button
    {
        return downArrowButton;
    }


}

}
",12080,False,2232.2848698424536,median
"#include <dummy.h>

/*

  TimeLapseAvi

  ESP32-CAM Video Recorder

  This program records an AVI video on the SD Card of an ESP32-CAM.

  by James Zahary July 20, 2019  TimeLapseAvi23x.ino
     jamzah.plc@gmail.com

  https://github.com/jameszah/ESP32-CAM-Video-Recorder

    jameszah/ESP32-CAM-Video-Recorder is licensed under the
    GNU General Public License v3.0

  The is Arduino code, with standard setup for ESP32-CAM
    - Board ESP32 Wrover Module
    - Partition Scheme Huge APP (3MB No OTA)

*/

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  edit these parameters for your needs

static const char vernum[] = ""v20061"";
static const char devname[] = ""desklens"";         // name of your camera for mDNS, Router, and filenames


#define TIMEZONE ""CST-8""             // your timezone  -  this is GMT


// 1 for blink red led with every sd card write, at your frame rate
// 0 for blink only for skipping frames and SOS if camera or sd is broken
#define BlinkWithWrite 0

// EDIT ssid and password
const char ssid[] = ""LinkTest"";           // your wireless network name (SSID)
const char password[] = ""87654321"";  // your Wi-Fi network password

// startup defaults for first recording

// here are the recording options from the ""retart web page"" 
// VGA 10 fps for 30 min, repeat, realtime                   http://192.168.0.117/start?framesize=VGA&length=1800&interval=100&quality=10&repeat=100&speed=1&gray=0
// VGA 2 fps, for 30 minutes repeat, 30x playback            http://192.168.0.117/start?framesize=VGA&length=1800&interval=500&quality=10&repeat=300&speed=30&gray=0
// UXGA 1 sec per frame, for 30 minutes repeat, 30x playback http://192.168.0.117/start?framesize=UXGA&length=1800&interval=1000&quality=10&repeat=100&speed=30&gray=0
// UXGA 2 fps for 30 minutes repeat, 15x playback            http://192.168.0.117/start?framesize=UXGA&length=1800&interval=500&quality=10&repeat=100&speed=30&gray=0
// CIF 20 fps second for 30 minutes repeat                   http://192.168.0.117/start?framesize=CIF&length=1800&interval=50&quality=10&repeat=100&speed=1&gray=0

// reboot startup parameters here

int record_on_reboot = 0;          // set to 1 to record, or 0 to NOT record on reboot
int  framesize = 7;                // vga  (10 UXGA, 7 SVGA, 6 VGA, 5 CIF)
int  repeat = 100;                 // 100 files
int  xspeed = 1;                   // 1x playback speed (realtime is 1)
int  gray = 0;                     // not gray
int  quality = 10;                 // 10 on the 0..64 scale, or 10..50 subscale - 10 is good, 20 is grainy and smaller files
int  capture_interval = 100;       // 100 ms or 10 frames per second
int  total_frames = 18000;         // 18000 frames = 10 fps * 60 seconds * 30 minutes = half hour

int PIRpin = 12;  

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

int  new_config = 5;         // this system abandoned !
int  xlength = total_frames * capture_interval / 1000;
int recording = 0;
int PIRstatus = 0;
int PIRrecording = 0;
int ready = 0;

//#define LOG_LOCAL_LEVEL ESP_LOG_VERBOSE
#include ""esp_log.h""
#include ""esp_http_server.h""
#include ""esp_camera.h""

#include <ESPmDNS.h>

#include ""ESP32FtpServer.h""
#include <HTTPClient.h>

FtpServer ftpSrv;   //set #define FTP_DEBUG in ESP32FtpServer.h to see ftp verbose on serial

// Time
#include ""time.h""

// MicroSD
#include ""driver/sdmmc_host.h""
#include ""driver/sdmmc_defs.h""
#include ""sdmmc_cmd.h""
#include ""esp_vfs_fat.h""
#include <SD_MMC.h>

long current_millis;
long last_capture_millis = 0;
static esp_err_t cam_err;
static esp_err_t card_err;
char strftime_buf[64];
int file_number = 0;
bool internet_connected = false;
struct tm timeinfo;
time_t now;

char *filename ;
char *stream ;
int newfile = 0;
int frames_so_far = 0;
FILE *myfile;
long bp;
long ap;
long bw;
long aw;
long totalp;
long totalw;
float avgp;
float avgw;
int overtime_count = 0;

// CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22


// GLOBALS
#define BUFFSIZE 512

// global variable used by these pieces

char str[20];
uint16_t n;
uint8_t buf[BUFFSIZE];

static int i = 0;
uint8_t temp = 0, temp_last = 0;
unsigned long fileposition = 0;
uint16_t frame_cnt = 0;
uint16_t remnant = 0;
uint32_t length = 0;
uint32_t startms;
uint32_t elapsedms;
uint32_t uVideoLen = 0;
bool is_header = false;
long bigdelta = 0;
int other_cpu_active = 0;
int skipping = 0;
int skipped = 0;

int fb_max = 12;

camera_fb_t * fb_q[30];
int fb_in = 0;
int fb_out = 0;

camera_fb_t * fb = NULL;

FILE *avifile = NULL;
FILE *idxfile = NULL;


#define AVIOFFSET 240 // AVI main header length

unsigned long movi_size = 0;
unsigned long jpeg_size = 0;
unsigned long idx_offset = 0;

uint8_t zero_buf[4] = {0x00, 0x00, 0x00, 0x00};
uint8_t   dc_buf[4] = {0x30, 0x30, 0x64, 0x63};    // ""00dc""
uint8_t avi1_buf[4] = {0x41, 0x56, 0x49, 0x31};    // ""AVI1""
uint8_t idx1_buf[4] = {0x69, 0x64, 0x78, 0x31};    // ""idx1""

uint8_t  vga_w[2] = {0x80, 0x02}; // 640
uint8_t  vga_h[2] = {0xE0, 0x01}; // 480
uint8_t  cif_w[2] = {0x90, 0x01}; // 400
uint8_t  cif_h[2] = {0x28, 0x01}; // 296
uint8_t svga_w[2] = {0x20, 0x03}; // 800
uint8_t svga_h[2] = {0x58, 0x02}; // 600
uint8_t uxga_w[2] = {0x40, 0x06}; // 1600
uint8_t uxga_h[2] = {0xB0, 0x04}; // 1200


const int avi_header[AVIOFFSET] PROGMEM = {
  0x52, 0x49, 0x46, 0x46, 0xD8, 0x01, 0x0E, 0x00, 0x41, 0x56, 0x49, 0x20, 0x4C, 0x49, 0x53, 0x54,
  0xD0, 0x00, 0x00, 0x00, 0x68, 0x64, 0x72, 0x6C, 0x61, 0x76, 0x69, 0x68, 0x38, 0x00, 0x00, 0x00,
  0xA0, 0x86, 0x01, 0x00, 0x80, 0x66, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
  0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x80, 0x02, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, 0x49, 0x53, 0x54, 0x84, 0x00, 0x00, 0x00,
  0x73, 0x74, 0x72, 0x6C, 0x73, 0x74, 0x72, 0x68, 0x30, 0x00, 0x00, 0x00, 0x76, 0x69, 0x64, 0x73,
  0x4D, 0x4A, 0x50, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, 0x74, 0x72, 0x66,
  0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00,
  0x01, 0x00, 0x18, 0x00, 0x4D, 0x4A, 0x50, 0x47, 0x00, 0x84, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x46, 0x4F,
  0x10, 0x00, 0x00, 0x00, 0x6A, 0x61, 0x6D, 0x65, 0x73, 0x7A, 0x61, 0x68, 0x61, 0x72, 0x79, 0x20,
  0x76, 0x36, 0x30, 0x20, 0x4C, 0x49, 0x53, 0x54, 0x00, 0x01, 0x0E, 0x00, 0x6D, 0x6F, 0x76, 0x69,
};



bool timeSet = 0;//未设置系统时间 暂停移动侦测
// Motion detection test - looks for diffs between camera images.
#include ""motionDetect.h""
bool debug = true;
uint8_t fsizePtr = FRAMESIZE_SVGA; // framesize selection
uint8_t lightLevel; // Current ambient light level 
uint8_t nightSwitch = 10; // white level % for night/day switching
uint8_t motionVal = 7; // motion sensitivity difference setting
bool haveMotion = false;
long lastDetection = 0;//上一次检测的时间 

struct frameStruct {
  const char* frameSizeStr;
  const uint16_t frameWidth;
  const uint16_t frameHeight;
  const uint16_t defaultFPS;
  const uint8_t scaleFactor;
  const uint8_t sampleRate;
};
// sample factors, 5th arg is scaling factor (1..N), 6th arg is sample factor (0..3)
// indexed by frame size - needs to be consistent with sensor.h enum
// #include ""sensor.h""
extern const frameStruct frameData[] = {
  {""QQVGA"", 160, 120, 25, 2, 1},
  {""n/a"", 0, 0, 0, 0, 1}, 
  {""n/a"", 0, 0, 0, 0, 1}, 
  {""HQVGA"", 240, 176, 25, 3, 1}, 
  {""QVGA"", 320, 240, 25, 3, 1}, 
  {""CIF"", 400, 296, 25, 3, 1},
  {""VGA"", 640, 480, 15, 3, 2}, 
  {""SVGA"", 800, 600, 10, 3, 2}, 
  {""XGA"", 1024, 768, 5, 3, 3}, 
  {""SXGA"", 1280, 1024, 3, 3, 4}, 
  {""UXGA"", 1600, 1200, 2, 6, 5}  
};

bool motionDetection(camera_fb_t* fb, bool motionStatus);
bool isNight(uint8_t nightSwitch);




//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// AviWriterTask runs on cpu 1 to write the avi file
//

TaskHandle_t CameraTask, AviWriterTask;
SemaphoreHandle_t baton;
int counter = 0;

void codeForAviWriterTask( void * parameter )
{

  for (;;) {
    if (ready) {
      make_avi();
    }
    delay(1);
  }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// CameraTask runs on cpu 0 to take pictures and drop them in a queue
//

void codeForCameraTask( void * parameter )
{

  for (;;) {

    if (other_cpu_active == 1 ) {
      current_millis = millis();
      if (current_millis - last_capture_millis > capture_interval) {

        last_capture_millis = millis();

        xSemaphoreTake( baton, portMAX_DELAY );

        if  ( ( (fb_in + fb_max - fb_out) % fb_max) + 1 == fb_max ) {
          xSemaphoreGive( baton );

          Serial.print("" Queue Full, Skipping ... "");  // the queue is full
          skipped++;
          skipping = 1;

        }

        if (skipping > 0 ) {


          if (!BlinkWithWrite) {
            digitalWrite(33, LOW);
          }

          if (skipping % 2 == 0) {  // skip every other frame until queue is cleared

            frames_so_far = frames_so_far + 1;
            frame_cnt++;

            fb_in = (fb_in + 1) % fb_max;
            bp = millis();
            fb_q[fb_in] = esp_camera_fb_get();
            totalp = totalp - bp + millis();

          } else {
            Serial.print(((fb_in + fb_max - fb_out) % fb_max));  // skip an extra frame to empty the queue
            skipped++;
          }
          skipping = skipping + 1;
          if (((fb_in + fb_max - fb_out) % fb_max) == 0 ) {
            skipping = 0;
            Serial.println("" Queue cleared. "");
          }

          xSemaphoreGive( baton );

        } else {

          skipping = 0;
          frames_so_far = frames_so_far + 1;
          frame_cnt++;

          fb_in = (fb_in + 1) % fb_max;
          bp = millis();
          fb_q[fb_in] = esp_camera_fb_get();
          totalp = totalp - bp + millis();
          xSemaphoreGive( baton );

        }
      }
    }
    delay(1);
  }
}


//
// Writes an uint32_t in Big Endian at current file position
//
static void inline print_quartet(unsigned long i, FILE * fd)
{
  uint8_t x[1];

  x[0] = i % 0x100;
  size_t i1_err = fwrite(x , 1, 1, fd);
  i = i >> 8;  x[0] = i % 0x100;
  size_t i2_err = fwrite(x , 1, 1, fd);
  i = i >> 8;  x[0] = i % 0x100;
  size_t i3_err = fwrite(x , 1, 1, fd);
  i = i >> 8;  x[0] = i % 0x100;
  size_t i4_err = fwrite(x , 1, 1, fd);
}


void startCameraServer();
httpd_handle_t camera_httpd = NULL;

char the_page[3000];

char localip[20];
WiFiEventId_t eventID;

#include ""soc/soc.h""
#include ""soc/rtc_cntl_reg.h""

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// setup() runs on cpu 1
//

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector  // creates other problems
  delay(1000);//电容充电
  Serial.begin(115200);

  Serial.setDebugOutput(true);

  // zzz
  Serial.println(""                                    "");
  Serial.println(""-------------------------------------"");
  Serial.printf(""ESP-CAM Video Recorder %s\\n"", vernum);
  Serial.printf("" http://%s.local - to access the camera\\n"", devname);
  Serial.println(""-------------------------------------"");

  pinMode(33, OUTPUT);    // little red led on back of chip
  digitalWrite(33, LOW);           // turn on the red LED on the back of chip
  
  if (init_wifi()) { // Connected to WiFi
    internet_connected = true;
  }
  // init_time();//离线模式不需要设置时间

  if (!psramFound()) {
    Serial.println(""paraFound wrong - major fail"");
    major_fail();
  }

  // SD camera init
  card_err = init_sdcard();
  if (card_err != ESP_OK) {
    Serial.printf(""SD Card init failed with error 0x%x"", card_err);
    major_fail();
    return;
  }

  startCameraServer();

  // zzz username and password for ftp server

  ftpSrv.begin(""esp"", ""esp"");

  Serial.printf(""Total space: %lluMB\\n"", SD_MMC.totalBytes() / (1024 * 1024));
  Serial.printf(""Used space: %lluMB\\n"", SD_MMC.usedBytes() / (1024 * 1024));

  digitalWrite(33, HIGH);         // red light turns off when setup is complete

  baton = xSemaphoreCreateMutex();

  xTaskCreatePinnedToCore(
    codeForCameraTask,
    ""CameraTask"",
    10000,
    NULL,
    1,
    &CameraTask,
    0);

  delay(50);

  xTaskCreatePinnedToCore(
    codeForAviWriterTask,
    ""AviWriterTask"",
    10000,
    NULL,
    2,
    &AviWriterTask,
    1);

  delay(50);


  recording = 0;  // we are NOT recording
  config_camera();


  pinMode(4, OUTPUT);                 // using 1 bit mode, shut off the Blinding Disk-Active Light
  digitalWrite(4, LOW);

  pinMode(PIRpin, INPUT_PULLDOWN);    // or PULLDOWN for active high

  newfile = 0;    // no file is open  // don't fiddle with this!

  recording = record_on_reboot;
 
  ready = 1;

  Serial.print(""Camera Ready! Use 'http://"");
  Serial.print(WiFi.softAPIP());
  Serial.println(""' to connect"");


}


//
// if we have no camera, or sd card, then flash rear led on and off to warn the human SOS - SOS
//
void major_fail() {

  Serial.println("" "");

  for  (int i = 0;  i < 10; i++) {                 // 10 loops or about 100 seconds then reboot
    digitalWrite(33, LOW);   delay(150);
    digitalWrite(33, HIGH);  delay(150);
    digitalWrite(33, LOW);   delay(150);
    digitalWrite(33, HIGH);  delay(150);
    digitalWrite(33, LOW);   delay(150);
    digitalWrite(33, HIGH);  delay(150);

    delay(1000);

    digitalWrite(33, LOW);  delay(500);
    digitalWrite(33, HIGH); delay(500);
    digitalWrite(33, LOW);  delay(500);
    digitalWrite(33, HIGH); delay(500);
    digitalWrite(33, LOW);  delay(500);
    digitalWrite(33, HIGH); delay(500);

    delay(1000);
    Serial.print(""Major Fail  ""); Serial.print(i); Serial.print("" / ""); Serial.println(10);
  }

  ESP.restart();

}

void init_time(){
  
  // configTime(0, 0, ""pool.ntp.org"");
  setenv(""TZ"", TIMEZONE, 1);  // mountain time zone from #define at top
  tzset();

  time_t now ;
  timeinfo = { 0 };
  int retry = 0;
  const int retry_count = 10;
  delay(1000);
  time(&now);
  localtime_r(&now, &timeinfo);

  while (timeinfo.tm_year < (2016 - 1900) && ++retry < retry_count) {
    Serial.printf(""Waiting for system time to be set... (%d/%d) -- %d\\n"", retry, retry_count, timeinfo.tm_year);
    delay(1000);
    time(&now);
    localtime_r(&now, &timeinfo);
  }

  Serial.println(ctime(&now));
}
bool init_wifi()
{
  int connAttempts = 0;

  // WiFi.disconnect(true);
  WiFi.mode(WIFI_AP);
  // Set your Static IP address
  IPAddress local_IP(10, 10, 1, 1);
  // Set your Gateway IP address
  IPAddress gateway(10, 10, 1, 1);
  IPAddress subnet(255, 255, 255, 0);
  WiFi.setHostname(devname);
  //WiFi.printDiag(Serial);
  WiFi.softAP(ssid, password);
  delay(1000);
  // while (WiFi.status() != WL_CONNECTED ) {
  //   delay(500);
  //   Serial.print(""."");
  //   if (connAttempts == 10) {
  //     Serial.println(""Cannot connect - try again"");
  //     WiFi.begin(ssid, password);
  //     WiFi.printDiag(Serial);
  //   }
  //   if (connAttempts == 20) {
  //     Serial.println(""Cannot connect - fail"");

  //     WiFi.printDiag(Serial);
  //     return false;
  //   }
  //   connAttempts++;
  // }

  Serial.println(""AP start"");
  sprintf(localip, ""%s"", WiFi.softAPIP().toString().c_str());
  //WiFi.printDiag(Serial);

  if (!MDNS.begin(devname)) {
    Serial.println(""Error setting up MDNS responder!"");
  } else {
    Serial.printf(""mDNS responder started '%s'\\n"", devname);
  }

  return true;

}


static esp_err_t init_sdcard()
{
  esp_err_t ret = ESP_FAIL;
  sdmmc_host_t host = SDMMC_HOST_DEFAULT();
  host.flags = SDMMC_HOST_FLAG_1BIT;                       // using 1 bit mode
  host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
  sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
  slot_config.width = 1;                                   // using 1 bit mode
  //Serial.print(""Slot config width should be 4 width:  ""); Serial.println(slot_config.width);
  esp_vfs_fat_sdmmc_mount_config_t mount_config = {
    .format_if_mount_failed = false,
    .max_files = 5,
  };

  //pinMode(4, OUTPUT);                 // using 1 bit mode, shut off the Blinding Disk-Active Light
  //digitalWrite(4, LOW);

  sdmmc_card_t *card;

  Serial.println(""Mounting SD card..."");
  ret = esp_vfs_fat_sdmmc_mount(""/sdcard"", &host, &slot_config, &mount_config, &card);

  if (ret == ESP_OK) {
    Serial.println(""SD card mount successfully!"");
  }  else  {
    Serial.printf(""Failed to mount SD card VFAT filesystem. Error: %s"", esp_err_to_name(ret));
    major_fail();
  }
  sdmmc_card_print_info(stdout, card);
  Serial.print(""SD_MMC Begin: ""); Serial.println(SD_MMC.begin());   // required by ftp system ??
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Make the avi move in 4 pieces
//
// make_avi() called in every loop, which calls below, depending on conditions
//   start_avi() - open the file and write headers
//   another_pic_avi() - write one more frame of movie
//   end_avi() - write the final parameters and close the file

void make_avi( ) {
  //摄像头移动侦测
  if (timeSet == 1)//当时间设置完才开始移动侦测
  {
    // if (millis() - lastDetection > 200){
    //   xSemaphoreTake( baton, portMAX_DELAY );
    //   camera_fb_t* fb = esp_camera_fb_get();
    //   lastDetection = millis();
    //   if (fb) {
    //     // uint8_t nightSwitch = 10; // white level % for night/day switching
    //     // isNight(nightSwitch);
    //     haveMotion = motionDetection(fb, haveMotion);
    //     if (haveMotion == 1 && isNight(10))
    //     {
    //       haveMotion = 0;
    //     }
        
        

    //     Serial.println(haveMotion);
    //     esp_camera_fb_return(fb); 
    //   } else Serial.println(""detection:Failed to get frame"");
    //   xSemaphoreGive( baton );
    //   if(millis() - lastDetection > 4000){
    //     haveMotion = false;
    //   }
    // }
    if (haveMotion == 1) {

      if (PIRrecording == 1) {
        // keep recording for 15 more seconds
        if ( (millis() - startms) > (total_frames * capture_interval - 5000)  ) {

          total_frames = total_frames + 10000 / capture_interval ;
          Serial.println(""Add another 10 seconds"");
        }

      } else {

        if ( recording == 0 && newfile == 0) {

          //start a pir recording with current parameters, except no repeat and 15 seconds
          Serial.println(""Start a PIR(by cam)"");
          PIRrecording = 1;
          repeat = 0;
          total_frames = 15000 / capture_interval;
          xlength = total_frames * capture_interval / 1000;
          recording = 1;
        }
      }
    }
  }

  // 红外热释电移动侦测
  PIRstatus = digitalRead(PIRpin);
  if (PIRstatus == 1) {

    if (PIRrecording == 1) {
      // keep recording for 15 more seconds
      if ( (millis() - startms) > (total_frames * capture_interval - 5000)  ) {
        // total_frames = total_frames + 10 * 1000 / capture_interval ;
        total_frames = total_frames + 10000 / capture_interval ;
        Serial.println(""Add another 10 seconds"");
      }

    } else {

      if ( recording == 0 && newfile == 0) {

        //start a pir recording with current parameters, except no repeat and 15 seconds
        Serial.println(""Start a PIR"");
        PIRrecording = 1;
        repeat = 0;
        total_frames = 15000 / capture_interval;
        xlength = total_frames * capture_interval / 1000;
        recording = 1;
      }
    }
  }


  // we are recording, but no file is open

  if (newfile == 0 && recording == 1) {                                     // open the file

    digitalWrite(33, HIGH);
    newfile = 1;
    start_avi();

  } else {

    // we have a file open, but not recording

    if (newfile == 1 && recording == 0) {                                  // got command to close file

      digitalWrite(33, LOW);
      end_avi();

      Serial.println(""Done capture due to command"");

      frames_so_far = total_frames;

      newfile = 0;    // file is closed
      recording = 0;  // DO NOT start another recording
      PIRrecording = 0;

    } else {

      if (newfile == 1 && recording == 1) {                            // regular recording

        if (frames_so_far >= total_frames)  {                                // we are done the recording

          Serial.println(""Done capture for total frames!"");

          digitalWrite(33, LOW);                                                       // close the file
          end_avi();

          frames_so_far = 0;
          newfile = 0;          // file is closed

          if (repeat > 0) {
            recording = 1;        // start another recording
            repeat = repeat - 1;
          } else {
            recording = 0;
            PIRrecording = 0;
          }

        } else if ((millis() - startms) > (total_frames * capture_interval)) {  // time is up, even though we have not done all the frames

          Serial.println ("" ""); Serial.println(""Done capture for time"");
          Serial.print(""Time Elapsed: ""); Serial.print(millis() - startms); Serial.print("" Frames: ""); Serial.println(frame_cnt);
          Serial.print(""Config:       ""); Serial.print(total_frames * capture_interval ) ; Serial.print("" ("");
          Serial.print(total_frames); Serial.print("" x ""); Serial.print(capture_interval);  Serial.println("")"");

          digitalWrite(33, LOW);                                                       // close the file

          end_avi();

          frames_so_far = 0;
          newfile = 0;          // file is closed
          if (repeat > 0) {
            recording = 1;        // start another recording
            repeat = repeat - 1;
          } else {
            recording = 0;
            PIRrecording = 0;
          }

        } else  {                                                            // regular

          another_save_avi();

        }
      }
    }
  }
}

static esp_err_t config_camera() {

  camera_config_t config;

  //Serial.println(""config camera"");

  if (new_config == 5) {

    config.ledc_channel = LEDC_CHANNEL_0;
    config.ledc_timer = LEDC_TIMER_0;
    config.pin_d0 = Y2_GPIO_NUM;
    config.pin_d1 = Y3_GPIO_NUM;
    config.pin_d2 = Y4_GPIO_NUM;
    config.pin_d3 = Y5_GPIO_NUM;
    config.pin_d4 = Y6_GPIO_NUM;
    config.pin_d5 = Y7_GPIO_NUM;
    config.pin_d6 = Y8_GPIO_NUM;
    config.pin_d7 = Y9_GPIO_NUM;
    config.pin_xclk = XCLK_GPIO_NUM;
    config.pin_pclk = PCLK_GPIO_NUM;
    config.pin_vsync = VSYNC_GPIO_NUM;
    config.pin_href = HREF_GPIO_NUM;
    config.pin_sscb_sda = SIOD_GPIO_NUM;
    config.pin_sscb_scl = SIOC_GPIO_NUM;
    config.pin_pwdn = PWDN_GPIO_NUM;
    config.pin_reset = RESET_GPIO_NUM;
    config.xclk_freq_hz = 20000000;
    config.pixel_format = PIXFORMAT_JPEG;

    config.frame_size = FRAMESIZE_UXGA;

    fb_max = 7;                                 // for vga and uxga
    config.jpeg_quality = 8;
    config.fb_count = fb_max + 1;

    // camera init
    cam_err = esp_camera_init(&config);
    if (cam_err != ESP_OK) {
      Serial.printf(""Camera init failed with error 0x%x"", cam_err);
      major_fail();
    }

    new_config = 2;

  }

  delay(100);

  sensor_t * ss = esp_camera_sensor_get();
  ss->set_quality(ss, quality);
  ss->set_framesize(ss, (framesize_t)framesize);
  if (gray == 1) {
    ss->set_special_effect(ss, 2);  // 0 regular, 2 grayscale
  } else {
    ss->set_special_effect(ss, 0);  // 0 regular, 2 grayscale
  }

  for (int j = 0; j < 3; j++) {
    do_fb();  // start the camera ... warm it up
    delay(1);
  }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// start_avi - open the files and write in headers
//

static esp_err_t start_avi() {

  Serial.println(""Starting an avi "");

  config_camera();

  time(&now);
  localtime_r(&now, &timeinfo);

  strftime(strftime_buf, sizeof(strftime_buf), ""%F_%H.%M.%S"", &timeinfo);

  char fname[100];

  if (framesize == 6) {
    sprintf(fname, ""/sdcard/%s_%s_vga_Q%d_I%d_L%d_S%d.avi"", devname, strftime_buf, quality, capture_interval, xlength, xspeed);
  } else if (framesize == 7) {
    sprintf(fname, ""/sdcard/%s_%s_svga_Q%d_I%d_L%d_S%d.avi"", devname,  strftime_buf, quality, capture_interval, xlength, xspeed);
  } else if (framesize == 10) {
    sprintf(fname, ""/sdcard/%s_%s_uxga_Q%d_I%d_L%d_S%d.avi"", devname, strftime_buf, quality, capture_interval, xlength, xspeed);
  } else  if (framesize == 5) {
    sprintf(fname, ""/sdcard/%s_%s_cif_Q%d_I%d_L%d_S%d.avi"", devname, strftime_buf, quality, capture_interval, xlength, xspeed);
  } else {
    Serial.println(""Wrong framesize"");
    sprintf(fname, ""/sdcard/%s_%s_xxx_Q%d_I%d_L%d_S%d.avi"", devname, strftime_buf, quality, capture_interval, xlength, xspeed);
  }

  Serial.print(""\\nFile name will be >""); Serial.print(fname); Serial.println(""<"");

  avifile = fopen(fname, ""w"");
  idxfile = fopen(""/sdcard/idx.tmp"", ""w"");

  if (avifile != NULL)  {

    //Serial.printf(""File open: %s\\n"", fname);

  }  else  {
    Serial.println(""Could not open file"");
    major_fail();
  }

  if (idxfile != NULL)  {

    //Serial.printf(""File open: %s\\n"", ""/sdcard/idx.tmp"");

  }  else  {
    Serial.println(""Could not open file"");
    major_fail();
  }


  for ( i = 0; i < AVIOFFSET; i++)
  {
    char ch = pgm_read_byte(&avi_header[i]);
    buf[i] = ch;
  }

  size_t err = fwrite(buf, 1, AVIOFFSET, avifile);

  if (framesize == 6) {

    fseek(avifile, 0x40, SEEK_SET);
    err = fwrite(vga_w, 1, 2, avifile);
    fseek(avifile, 0xA8, SEEK_SET);
    err = fwrite(vga_w, 1, 2, avifile);
    fseek(avifile, 0x44, SEEK_SET);
    err = fwrite(vga_h, 1, 2, avifile);
    fseek(avifile, 0xAC, SEEK_SET);
    err = fwrite(vga_h, 1, 2, avifile);

  } else if (framesize == 10) {

    fseek(avifile, 0x40, SEEK_SET);
    err = fwrite(uxga_w, 1, 2, avifile);
    fseek(avifile, 0xA8, SEEK_SET);
    err = fwrite(uxga_w, 1, 2, avifile);
    fseek(avifile, 0x44, SEEK_SET);
    err = fwrite(uxga_h, 1, 2, avifile);
    fseek(avifile, 0xAC, SEEK_SET);
    err = fwrite(uxga_h, 1, 2, avifile);

  } else if (framesize == 7) {

    fseek(avifile, 0x40, SEEK_SET);
    err = fwrite(svga_w, 1, 2, avifile);
    fseek(avifile, 0xA8, SEEK_SET);
    err = fwrite(svga_w, 1, 2, avifile);
    fseek(avifile, 0x44, SEEK_SET);
    err = fwrite(svga_h, 1, 2, avifile);
    fseek(avifile, 0xAC, SEEK_SET);
    err = fwrite(svga_h, 1, 2, avifile);

  }  else if (framesize == 5) {

    fseek(avifile, 0x40, SEEK_SET);
    err = fwrite(cif_w, 1, 2, avifile);
    fseek(avifile, 0xA8, SEEK_SET);
    err = fwrite(cif_w, 1, 2, avifile);
    fseek(avifile, 0x44, SEEK_SET);
    err = fwrite(cif_h, 1, 2, avifile);
    fseek(avifile, 0xAC, SEEK_SET);
    err = fwrite(cif_h, 1, 2, avifile);
  }

  fseek(avifile, AVIOFFSET, SEEK_SET);

  Serial.print(F(""\\nRecording ""));
  Serial.print(total_frames);
  Serial.println(F("" video frames ...\\n""));

  startms = millis();
  bigdelta = millis();
  totalp = 0;
  totalw = 0;
  overtime_count = 0;
  jpeg_size = 0;
  movi_size = 0;
  uVideoLen = 0;
  idx_offset = 4;


  frame_cnt = 0;
  frames_so_far = 0;

  skipping = 0;
  skipped = 0;

  newfile = 1;

  other_cpu_active = 1;

} // end of start avi

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//  another_save_avi runs on cpu 1, saves another frame to the avi file
//
//  the ""baton"" semaphore makes sure that only one cpu is using the camera subsystem at a time
//

static esp_err_t another_save_avi() {

  xSemaphoreTake( baton, portMAX_DELAY );

  if (fb_in == fb_out) {        // nothing to do

    xSemaphoreGive( baton );

  } else {

    fb_out = (fb_out + 1) % fb_max;

    int fblen;
    fblen = fb_q[fb_out]->len;

    //xSemaphoreGive( baton );

    if (BlinkWithWrite) {
      digitalWrite(33, LOW);
    }

    jpeg_size = fblen;
    movi_size += jpeg_size;
    uVideoLen += jpeg_size;

    bw = millis();
    size_t dc_err = fwrite(dc_buf, 1, 4, avifile);
    size_t ze_err = fwrite(zero_buf, 1, 4, avifile);

    bw = millis();
    size_t err = fwrite(fb_q[fb_out]->buf, 1, fb_q[fb_out]->len, avifile);
    if (err == 0 ) {
      Serial.println(""Error on avi write"");
      major_fail();
    }
    totalw = totalw + millis() - bw;

    //xSemaphoreTake( baton, portMAX_DELAY );
    esp_camera_fb_return(fb_q[fb_out]);     // release that buffer back to the camera system
    xSemaphoreGive( baton );

    remnant = (4 - (jpeg_size & 0x00000003)) & 0x00000003;

    print_quartet(idx_offset, idxfile);
    print_quartet(jpeg_size, idxfile);

    idx_offset = idx_offset + jpeg_size + remnant + 8;

    jpeg_size = jpeg_size + remnant;
    movi_size = movi_size + remnant;
    if (remnant > 0) {
      size_t rem_err = fwrite(zero_buf, 1, remnant, avifile);
    }

    fileposition = ftell (avifile);       // Here, we are at end of chunk (after padding)
    fseek(avifile, fileposition - jpeg_size - 4, SEEK_SET);    // Here we are the the 4-bytes blank placeholder

    print_quartet(jpeg_size, avifile);    // Overwrite placeholder with actual frame size (without padding)

    fileposition = ftell (avifile);

    fseek(avifile, fileposition + 6, SEEK_SET);    // Here is the FOURCC ""JFIF"" (JPEG header)
    // Overwrite ""JFIF"" (still images) with more appropriate ""AVI1""

    size_t av_err = fwrite(avi1_buf, 1, 4, avifile);

    fileposition = ftell (avifile);
    fseek(avifile, fileposition + jpeg_size - 10 , SEEK_SET);
    //Serial.println(""Write done"");
    //41 totalw = totalw + millis() - bw;

    //if (((fb_in + fb_max - fb_out) % fb_max) > 0 ) {
    //  Serial.print(((fb_in + fb_max - fb_out) % fb_max)); Serial.print("" "");
    //}

    digitalWrite(33, HIGH);
  }
} // end of another_pic_avi

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//  end_avi runs on cpu 1, empties the queue of frames, writes the index, and closes the files
//

static esp_err_t end_avi() {

  unsigned long current_end = 0;

  other_cpu_active = 0 ;  // shuts down the picture taking program

  //Serial.print("" Write Q: ""); Serial.print((fb_in + fb_max - fb_out) % fb_max); Serial.print("" in/out  ""); Serial.print(fb_in); Serial.print("" / ""); Serial.println(fb_out);

  for (int i = 0; i < fb_max; i++) {           // clear the queue
    another_save_avi();
  }

  //Serial.print("" Write Q: ""); Serial.print((fb_in + fb_max - fb_out) % fb_max); Serial.print("" in/out  ""); Serial.print(fb_in); Serial.print("" / ""); Serial.println(fb_out);

  current_end = ftell (avifile);

  Serial.println(""End of avi - closing the files"");

  elapsedms = millis() - startms;
  float fRealFPS = (1000.0f * (float)frame_cnt) / ((float)elapsedms) * xspeed;
  float fmicroseconds_per_frame = 1000000.0f / fRealFPS;
  uint8_t iAttainedFPS = round(fRealFPS);
  uint32_t us_per_frame = round(fmicroseconds_per_frame);


  //Modify the MJPEG header from the beginning of the file, overwriting various placeholders

  fseek(avifile, 4 , SEEK_SET);
  print_quartet(movi_size + 240 + 16 * frame_cnt + 8 * frame_cnt, avifile);

  fseek(avifile, 0x20 , SEEK_SET);
  print_quartet(us_per_frame, avifile);

  unsigned long max_bytes_per_sec = movi_size * iAttainedFPS / frame_cnt;

  fseek(avifile, 0x24 , SEEK_SET);
  print_quartet(max_bytes_per_sec, avifile);

  fseek(avifile, 0x30 , SEEK_SET);
  print_quartet(frame_cnt, avifile);

  fseek(avifile, 0x8c , SEEK_SET);
  print_quartet(frame_cnt, avifile);

  fseek(avifile, 0x84 , SEEK_SET);
  print_quartet((int)iAttainedFPS, avifile);

  fseek(avifile, 0xe8 , SEEK_SET);
  print_quartet(movi_size + frame_cnt * 8 + 4, avifile);

  Serial.println(F(""\\n*** Video recorded and saved ***\\n""));
  Serial.print(F(""Recorded ""));
  Serial.print(elapsedms / 1000);
  Serial.print(F(""s in ""));
  Serial.print(frame_cnt);
  Serial.print(F("" frames\\nFile size is ""));
  Serial.print(movi_size + 12 * frame_cnt + 4);
  Serial.print(F("" bytes\\nActual FPS is ""));
  Serial.print(fRealFPS, 2);
  Serial.print(F(""\\nMax data rate is ""));
  Serial.print(max_bytes_per_sec);
  Serial.print(F("" byte/s\\nFrame duration is ""));  Serial.print(us_per_frame);  Serial.println(F("" us""));
  Serial.print(F(""Average frame length is ""));  Serial.print(uVideoLen / frame_cnt);  Serial.println(F("" bytes""));
  Serial.print(""Average picture time (ms) ""); Serial.println( totalp / frame_cnt );
  Serial.print(""Average write time (ms)   ""); Serial.println( totalw / frame_cnt );
  Serial.print(""Frames Skipped % "");  Serial.println( 100.0 * skipped / total_frames, 1 );

  Serial.println(""Writing the index"");

  fseek(avifile, current_end, SEEK_SET);

  fclose(idxfile);

  size_t i1_err = fwrite(idx1_buf, 1, 4, avifile);

  print_quartet(frame_cnt * 16, avifile);

  idxfile = fopen(""/sdcard/idx.tmp"", ""r"");

  if (idxfile != NULL)  {

    //Serial.printf(""File open: %s\\n"", ""/sdcard/idx.tmp"");

  }  else  {
    Serial.println(""Could not open file"");
    //major_fail();
  }

  char * AteBytes;
  AteBytes = (char*) malloc (8);

  for (int i = 0; i < frame_cnt; i++) {
    size_t res = fread ( AteBytes, 1, 8, idxfile);
    size_t i1_err = fwrite(dc_buf, 1, 4, avifile);
    size_t i2_err = fwrite(zero_buf, 1, 4, avifile);
    size_t i3_err = fwrite(AteBytes, 1, 8, avifile);
  }

  free(AteBytes);
  fclose(idxfile);
  fclose(avifile);
  int xx = remove(""/sdcard/idx.tmp"");

  Serial.println(""---"");

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//  do_fb - just takes a picture and discards it
//

static esp_err_t do_fb() {
  xSemaphoreTake( baton, portMAX_DELAY );
  camera_fb_t * fb = esp_camera_fb_get();

  Serial.print(""Pic, len=""); Serial.println(fb->len);

  esp_camera_fb_return(fb);
  xSemaphoreGive( baton );
}



////////////////////////////////////////////////////////////////////////////////////
//
// some globals for the loop()
//

long wakeup;
long last_wakeup = 0;


void loop()
{

  wakeup = millis();
  if (wakeup - last_wakeup > (14 * 60 * 1000) ) {       // 14 minutes
    last_wakeup = millis();

    // do_time();
  }

  ftpSrv.handleFTP();

  //delay(1);

}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//

static esp_err_t capture_handler(httpd_req_t *req) {

  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  char fname[100];
  //xSemaphoreTake( baton, portMAX_DELAY );
  fb = esp_camera_fb_get();

  if (!fb) {
    Serial.println(""Camera capture failed"");
    httpd_resp_send_500(req);
    xSemaphoreGive( baton );
    return ESP_FAIL;
  }

  file_number++;

  sprintf(fname, ""inline; filename=capture_%d.jpg"", file_number);

  httpd_resp_set_type(req, ""image/jpeg"");
  httpd_resp_set_hdr(req, ""Content-Disposition"", fname);

  size_t out_len, out_width, out_height;
  size_t fb_len = 0;
  fb_len = fb->len;
  res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
  esp_camera_fb_return(fb);
  //xSemaphoreGive( baton );
  return res;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//
static esp_err_t stop_handler(httpd_req_t *req) {

  esp_err_t res = ESP_OK;

  recording = 0;
  Serial.println(""stopping recording"");

  do_stop(""Stopping previous recording"");

  httpd_resp_send(req, the_page, strlen(the_page));
  return ESP_OK;

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//
static esp_err_t start_handler(httpd_req_t *req) {

  esp_err_t res = ESP_OK;

  char  buf[80];
  size_t buf_len;
  char  new_res[20];

  if (recording == 1) {
    const char* resp = ""You must Stop recording, before starting a new one.  Start over ..."";
    httpd_resp_send(req, resp, strlen(resp));

    return ESP_OK;
    return res;

  } else {
    //recording = 1;
    Serial.println(""starting recording"");

    sensor_t * s = esp_camera_sensor_get();

    int new_interval = capture_interval;
    int new_length = capture_interval * total_frames;

    int new_framesize = s->status.framesize;
    int new_quality = s->status.quality;
    int new_repeat = 0;
    int new_xspeed = 1;
    int new_xlength = 3;
    int new_gray = 0;

    /*
        Serial.println("""");
        Serial.println(""Current Parameters :"");
        Serial.print(""  Capture Interval = ""); Serial.print(capture_interval);  Serial.println("" ms"");
        Serial.print(""  Length = ""); Serial.print(capture_interval * total_frames / 1000); Serial.println("" s"");
        Serial.print(""  Quality = ""); Serial.println(new_quality);
        Serial.print(""  Framesize = ""); Serial.println(new_framesize);
        Serial.print(""  Repeat = ""); Serial.println(repeat);
        Serial.print(""  Speed = ""); Serial.println(xspeed);
    */

    buf_len = httpd_req_get_url_query_len(req) + 1;
    if (buf_len > 1) {
      if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
        ESP_LOGI(TAG, ""Found URL query => %s"", buf);
        char param[32];
        /* Get value of expected key from query string */
        //Serial.println("" ... parameters"");
        if (httpd_query_key_value(buf, ""length"", param, sizeof(param)) == ESP_OK) {

          int x = atoi(param);
          if (x >= 5 && x <= 3600 * 24 ) {   // 5 sec to 24 hours
            new_length = x;
          }

          ESP_LOGI(TAG, ""Found URL query parameter => length=%s"", param);

        }
        if (httpd_query_key_value(buf, ""repeat"", param, sizeof(param)) == ESP_OK) {
          int x = atoi(param);
          if (x >= 0  ) {
            new_repeat = x;
          }

          ESP_LOGI(TAG, ""Found URL query parameter => repeat=%s"", param);
        }
        if (httpd_query_key_value(buf, ""framesize"", new_res, sizeof(new_res)) == ESP_OK) {
          if (strcmp(new_res, ""UXGA"") == 0) {
            new_framesize = 10;
          } else if (strcmp(new_res, ""SVGA"") == 0) {
            new_framesize = 7;
          } else if (strcmp(new_res, ""VGA"") == 0) {
            new_framesize = 6;
          } else if (strcmp(new_res, ""CIF"") == 0) {
            new_framesize = 5;
          } else {
            Serial.println(""Only UXGA, SVGA, VGA, and CIF are valid!"");

          }
          ESP_LOGI(TAG, ""Found URL query parameter => framesize=%s"", new_res);
        }
        if (httpd_query_key_value(buf, ""quality"", param, sizeof(param)) == ESP_OK) {

          int x = atoi(param);
          if (x >= 10 && x <= 50) {                 // MINIMUM QUALITY 10 to save memory
            new_quality = x;
          }

          ESP_LOGI(TAG, ""Found URL query parameter => quality=%s"", param);
        }

        if (httpd_query_key_value(buf, ""speed"", param, sizeof(param)) == ESP_OK) {

          int x = atoi(param);
          if (x >= 1 && x <= 100) {
            new_xspeed = x;
          }

          ESP_LOGI(TAG, ""Found URL query parameter => speed=%s"", param);
        }

        if (httpd_query_key_value(buf, ""gray"", param, sizeof(param)) == ESP_OK) {

          int x = atoi(param);
          if (x == 1 ) {
            new_gray = x;
          }

          ESP_LOGI(TAG, ""Found URL query parameter => gray=%s"", param);
        }

        if (httpd_query_key_value(buf, ""interval"", param, sizeof(param)) == ESP_OK) {

          int x = atoi(param);
          if (x >= 1 && x <= 180000) {  //  180,000 ms = 3 min
            new_interval = x;
          }
          ESP_LOGI(TAG, ""Found URL query parameter => interval=%s"", param);
        }
      }
    }

    framesize = new_framesize;
    capture_interval = new_interval;
    xlength = new_length;
    total_frames = new_length * 1000 / capture_interval;
    repeat = new_repeat;
    quality = new_quality;
    xspeed = new_xspeed;
    gray = new_gray;

    do_start(""Starting a new AVI"");
    httpd_resp_send(req, the_page, strlen(the_page));

    recording = 1;
    return ESP_OK;
  }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//
void do_start(char *the_message) {

  Serial.print(""do_start ""); Serial.println(the_message);

  const char msg[] PROGMEM = R""rawliteral(<!doctype html>
<html>
<head>
<meta charset=""utf-8"">
<meta name=""viewport"" content=""width=device-width,initial-scale=1"">
<title>%s ESP32-CAM Video Recorder</title>
</head>
<body>
<h1>%s<br>ESP32-CAM Video Recorder %s </h1><br>
 <h3>Message is <font color=""red"">%s</font></h3><br>
 Recording = %d (1 is active)<br>
 Capture Interval = %d ms<br>
 Length = %d seconds<br>
 Quality = %d (10 best to 50 worst)<br>
 Framesize = %d (10 UXGA, 7 SVGA, 6 VGA, 5 CIF)<br>
 Repeat = %d<br>
 Speed = %d<br>
 Gray = %d<br><br>

<br>
<br><div id=""image-container""></div>

</body>
</html>)rawliteral"";


  sprintf(the_page, msg, devname, devname, vernum, the_message, recording, capture_interval, capture_interval * total_frames / 1000, quality, framesize, repeat, xspeed, gray);
  //Serial.println(strlen(msg));

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//
void do_stop(char *the_message) {

  Serial.print(""do_stop ""); Serial.println(the_message);

  const char msg[] PROGMEM = R""rawliteral(<!doctype html>
<html>
<head>
<meta charset=""utf-8"">
<meta name=""viewport"" content=""width=device-width,initial-scale=1"">
<title>%s ESP32-CAM Video Recorder</title>
</head>
<body>
<h1>%s<br>ESP32-CAM Video Recorder %s </h1><br>
 <h3>Message is <font color=""red"">%s</font></h3><br>
 <h3><a href=""http://%s/"">http://%s/</a></h3>
 <h3><a href=""http://%s/start?framesize=VGA&length=1800&interval=100&quality=10&repeat=100&speed=1&gray=0"">http://%s/start?framesize=VGA&length=1800&interval=100&quality=10&repeat=100&speed=1&gray=0</a></h3> 
<h3><a href=""http://%s/start?framesize=VGA&length=1800&interval=500&quality=10&repeat=300&speed=30&gray=0"">VGA 2 fps, for 30 minutes repeat, 30x playback</a></h3>
<h3><a href=""http://%s/start?framesize=UXGA&length=1800&interval=1000&quality=10&repeat=100&speed=30&gray=0"">UXGA 1 sec per frame, for 30 minutes repeat, 30x playback</a></h3>
<h3><a href=""http://%s/start?framesize=UXGA&length=1800&interval=500&quality=10&repeat=100&speed=30&gray=0"">UXGA 2 fps for 30 minutes repeat, 15x playback</a></h3>
<h3><a href=""http://%s/start?framesize=CIF&length=1800&interval=50&quality=10&repeat=100&speed=1&gray=0"">CIF 20 fps second for 30 minutes repeat</a></h3>
<br>
</body>
</html>)rawliteral"";

  sprintf(the_page, msg, devname, devname, vernum, the_message, localip, localip, localip, localip, localip, localip, localip, localip);

}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//
void do_status(char *the_message) {

  Serial.print(""do_status ""); Serial.println(the_message);

  const char msg[] PROGMEM = R""rawliteral(<!doctype html>
<html>
<head>
<meta charset=""utf-8"">
<meta name=""viewport"" content=""width=device-width,initial-scale=1"">
<title>%s ESP32-CAM Video Recorder</title>
</head>
<body>
<h1>%s<br>ESP32-CAM Video Recorder %s <br><font color=""red"">%s</font></h1><br>
 <h3>Message is <font color=""red"">%s</font></h3><br>
 Total SD Space is %d MB, Used SD Space is %d MB<br>
 Recording = %d (1 is active)<br>
 Frame %d of %d, Skipped %d<br><br>
 Capture Interval = %d ms<br>
 Length = %d seconds<br>
 Quality = %d (10 best to 50 worst)<br>
 Framesize = %d (10 UXGA, 7 SVGA, 6 VGA, 5 CIF)<br>
 Repeat = %d<br>
 Playback Speed = %d<br>
 Gray = %d<br><br>
 Commands as follows for your ESP's ip address:<br>
 <h3><a href=""http://%s/"">http://%s/</a></h3>
 <h3><a href=""http://%s/stop"">http://%s/stop<font color=""red""> ... and restart<br>You must be stopped before restart or PIR</font></a></h3>
 <h3><a href=""ftp://%s/"">ftp://%s/</a></h3>
 Username: esp, Password: esp ... to download the files<br><br>
 Red LED on back of ESP will flash with every frame (or skipped frames), and flash SOS if camera or sd card not working.<br>

<br>
Check camera position with the frame below <br>
Refresh page for more.<br>
<br><div id=""image-container""></div>
<script>
document.addEventListener('DOMContentLoaded', function() {
  var c = document.location.origin;
  const ic = document.getElementById('image-container');  
  var i = 1;
  
  var timing = 5000;

  function loop() {
    ic.insertAdjacentHTML('beforeend','<img src=""'+`${c}/capture?_cb=${Date.now()}`+'"">')
    ic.insertAdjacentHTML('beforeend','<br>')
    ic.insertAdjacentHTML('beforeend',Date())
    ic.insertAdjacentHTML('beforeend','<br>')
    
    i = i + 1;
    if ( i < 2 ) {
      window.setTimeout(loop, timing);
    }
  }
  loop();
  
})
</script><br>
</body>
</html>)rawliteral"";

  time(&now);
  const char *strdate = ctime(&now);

  //Serial.printf(""Total space: %lluMB\\n"", SD_MMC.totalBytes() / (1024 * 1024));
  //Serial.printf(""Used space: %lluMB\\n"", SD_MMC.usedBytes() / (1024 * 1024));

  int tot = SD_MMC.totalBytes() / (1024 * 1024);
  int use = SD_MMC.usedBytes() / (1024 * 1024);

  //Serial.print(strlen(msg)); Serial.print("" "");

  sprintf(the_page, msg, devname, devname, vernum, strdate, the_message, tot, use, recording, frames_so_far, total_frames, skipped, capture_interval, capture_interval * total_frames / 1000, quality, framesize, repeat, xspeed, gray, localip, localip, localip, localip, localip, localip);

  //Serial.println(strlen(the_page));
}

static esp_err_t time_handler(httpd_req_t *req) {
  char  buf[80];
  size_t buf_len = httpd_req_get_url_query_len(req) + 1;

  if (buf_len > 1) {
    if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
      ESP_LOGI(TAG, ""Found URL query => %s"", buf);
      char param[32];
      /* Get value of expected key from query string */
      //Serial.println("" ... parameters"");

      int year = 0;
      int mon = 0;
      int day = 0;
      int hour = 0;
      int min = 0;
      int sec = 0;
      bool err = 0;
      
      if (httpd_query_key_value(buf, ""year"", param, sizeof(param)) == ESP_OK) {
        int x = atoi(param);
        Serial.println(x);
        if (x >= 1900 && x <= 2100 ) { 
          year = x;
          err = 0;
          Serial.println(year);
        }else{
          err = 1;
        }
      }
      if (httpd_query_key_value(buf, ""mon"", param, sizeof(param)) == ESP_OK) {
        int x = atoi(param);
        Serial.println(x);
        if (x >= 1 && x <= 12 ) { 
          mon = x;
          err = 0;
          Serial.println(mon);
        }else{
          err = 1;
        }
      }
      if (httpd_query_key_value(buf, ""day"", param, sizeof(param)) == ESP_OK) {
        int x = atoi(param);
        Serial.println(x);
        if (x >= 1 && x <= 31 ) { 
          day = x;
          err = 0;
          Serial.println(day);
        }else{
          err = 1;
        }
      }
      if (httpd_query_key_value(buf, ""hour"", param, sizeof(param)) == ESP_OK) {
        int x = atoi(param);
        Serial.println(x);
        if (x >= 0 && x <= 24 ) { 
          hour = x;
          err = 0;
          Serial.println(hour);
        }else{
          err = 1;
        }
      }
      if (httpd_query_key_value(buf, ""min"", param, sizeof(param)) == ESP_OK) {
        int x = atoi(param);
        Serial.println(x);
        if (x >= 0 && x <= 60 ) { 
          min = x;
          err = 0;
          Serial.println(min);
        }else{
          err = 1;
        }
      }
      if (httpd_query_key_value(buf, ""sec"", param, sizeof(param)) == ESP_OK) {
        int x = atoi(param);
        Serial.println(x);
        if (x >= 0 && x <= 60 ) { 
          sec = x;
          err = 0;
          Serial.println(sec);
        }else{
          err = 1;
        }
      }
      if (err != 1)
      {
        struct tm tmGet;
        tmGet.tm_year = year - 1900;
        tmGet.tm_mon = mon;
        tmGet.tm_mday = day;
        tmGet.tm_hour = hour;
        tmGet.tm_min = min;
        tmGet.tm_sec = sec;
        time_t t = mktime(&tmGet);
        printf(""Setting time: %s"", asctime(&tmGet));
        timeval tmSet = { .tv_sec = t };
        settimeofday(&tmSet, NULL);
        timeSet = 1;//时间设置完了
      }
      
    }
  }
  const char msg[] PROGMEM = R""rawliteral(Time:%s
<script>
  var myDate = new Date();
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      document.getElementById(""demo"").innerHTML = this.responseText;
    }
  };
  xhttp.open(""GET"", ""/time?year="" + myDate.getFullYear() + ""&mon="" + (myDate.getMonth()+1) + ""&day="" + myDate.getDate() + ""&hour="" + myDate.getHours() + ""&min="" + myDate.getMinutes() + ""&sec="" + myDate.getSeconds(), true);
  xhttp.send();
</script>)rawliteral"";
  struct tm timeinfo;
  getLocalTime(&timeinfo);
  sprintf(the_page, msg, asctime(&timeinfo) );
  httpd_resp_send(req, the_page, strlen(the_page));
  return ESP_OK; 
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//
static esp_err_t index_handler(httpd_req_t *req) {

  do_status(""Refresh Status"");
  httpd_resp_send(req, the_page, strlen(the_page));
  return ESP_OK;
}

void startCameraServer() {
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();

  httpd_uri_t index_uri = {
    .uri       = ""/"",
    .method    = HTTP_GET,
    .handler   = index_handler,
    .user_ctx  = NULL
  };
  httpd_uri_t capture_uri = {
    .uri       = ""/capture"",
    .method    = HTTP_GET,
    .handler   = capture_handler,
    .user_ctx  = NULL
  };

  httpd_uri_t file_stop = {
    .uri       = ""/stop"",
    .method    = HTTP_GET,
    .handler   = stop_handler,
    .user_ctx  = NULL
  };

  httpd_uri_t file_start = {
    .uri       = ""/start"",
    .method    = HTTP_GET,
    .handler   = start_handler,
    .user_ctx  = NULL
  };
  httpd_uri_t time_set = {
    .uri       = ""/time"",
    .method    = HTTP_GET,
    .handler   = time_handler,
    .user_ctx  = NULL
  };

  if (httpd_start(&camera_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(camera_httpd, &index_uri);
    httpd_register_uri_handler(camera_httpd, &capture_uri);
    httpd_register_uri_handler(camera_httpd, &file_start);
    httpd_register_uri_handler(camera_httpd, &file_stop);
    httpd_register_uri_handler(camera_httpd, &time_set);
  }

  Serial.println(""Camera http started"");
}
",16377,True,2688.743933257389,median
"/*

  PrintProgmem.ino
  
  AVR Architecture:
  Use the (Arduino compatible) u8g2 function ""print""  to draw a string,
  which is located in PROGMEM.
  For string constants use the F() macro, but this example use global 
  strings instead.

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7528_ERC16064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7528_ERC16064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


void setup(void) {
  u8g2.begin();
}

const char s[] PROGMEM = ""Progmem"";
const char s1[] PROGMEM  = ""ABC"" ;
const char s2[] PROGMEM  = ""DEF"" ;
const char s3[] PROGMEM  = ""GHI"" ;
const char s4[] PROGMEM  = ""JKL"" ;

const char *a[] = { s1, s2, s3, s4 };

int i = 0;

void loop(void) {
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.firstPage();
  do {
  
    u8g2.setCursor(0, 20);
    u8g2.print((class __FlashStringHelper *)s);   // print a sting, located in PROGMEM
    
    u8g2.setCursor(0, 40);
    u8g2.print((class __FlashStringHelper *)a[i]);  // print a sting (PROGMEM) via RAM array.
    
  } while ( u8g2.nextPage() );
  delay(1000);
  i++;
  if ( i >= 4 )
    i = 0;
}

",16264,True,5075.840637104752,median
"/*
Feathers
Copyright 2012-2013 Joshua Tynjala. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.controls
{
	import feathers.core.FeathersControl;
	import feathers.core.IFocusDisplayObject;
	import feathers.core.ITextRenderer;
	import feathers.core.IToggle;
	import feathers.core.PropertyProxy;
	import feathers.events.FeathersEventType;
	import feathers.system.DeviceCapabilities;

	import Loom2D.Math.Point;
	import Loom2D.Math.Rectangle;
	import flash.ui.Keyboard;

	import starling.animation.Transitions;
	import starling.animation.Tween;
	import Loom2D.Loom2D;
	import Loom2D.Display.DisplayObject;
	import Loom2D.Events.Event;
	import Loom2D.Events.KeyboardEvent;
	import Loom2D.Events.Touch;
	import Loom2D.Events.TouchEvent;
	import Loom2D.Events.TouchPhase;

	/**
	 * @inheritDoc
	 */
	[Event(name=""change"",type=""starling.events.Event"")]

	/**
	 * Similar to a light switch with on and off states. Generally considered an
	 * alternative to a check box.
	 *
	 * @see http://wiki.starling-framework.org/feathers/toggle-switch
	 * @see Check
	 */
	public class ToggleSwitch extends FeathersControl implements IToggle, IFocusDisplayObject
	{
		/**
		 * @private
		 */
		private static const HELPER_POINT:Point = new Point();

		/**
		 * @private
		 */
		private static const HELPER_TOUCHES_VECTOR:Vector.<Touch> = new <Touch>[];

		/**
		 * @private
		 * The minimum physical distance (in inches) that a touch must move
		 * before the scroller starts scrolling.
		 */
		private static const MINIMUM_DRAG_DISTANCE:Number = 0.04;

		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_THUMB_FACTORY:String = ""thumbFactory"";

		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_ON_TRACK_FACTORY:String = ""onTrackFactory"";

		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_OFF_TRACK_FACTORY:String = ""offTrackFactory"";

		/**
		 * The ON and OFF labels will be aligned to the middle vertically,
		 * based on the full character height of the font.
		 *
		 * @see #labelAlign
		 */
		public static const LABEL_ALIGN_MIDDLE:String = ""middle"";

		/**
		 * The ON and OFF labels will be aligned to the middle vertically,
		 * based on only the baseline value of the font.
		 *
		 * @see #labelAlign
		 */
		public static const LABEL_ALIGN_BASELINE:String = ""baseline"";

		/**
		 * The toggle switch has only one track skin, stretching to fill the
		 * full length of switch. In this layout mode, the on track is
		 * displayed and fills the entire length of the toggle switch. The off
		 * track will not exist.
		 *
		 * @see #trackLayoutMode
		 */
		public static const TRACK_LAYOUT_MODE_SINGLE:String = ""single"";

		/**
		 * The toggle switch has two tracks, stretching to fill each side of the
		 * scroll bar with the thumb in the middle. The tracks will be resized
		 * as the thumb moves. This layout mode is designed for toggle switches
		 * where the two sides of the track may be colored differently to better
		 * differentiate between the on state and the off state.
		 *
		 * Since the width and height of the tracks will change, consider
		 * sing a special display object such as a `Scale9Image`,
		 * `Scale3Image` or a `TiledImage` that is
		 * designed to be resized dynamically.
		 *
		 * @see #trackLayoutMode
		 * @see feathers.display.Scale9Image
		 * @see feathers.display.Scale3Image
		 * @see feathers.display.TiledImage
		 */
		public static const TRACK_LAYOUT_MODE_ON_OFF:String = ""onOff"";

		/**
		 * The default value added to the `nameList` of the off label.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_OFF_LABEL:String = ""feathers-toggle-switch-off-label"";

		/**
		 * The default value added to the `nameList` of the on label.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_ON_LABEL:String = ""feathers-toggle-switch-on-label"";

		/**
		 * The default value added to the `nameList` of the off track.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_OFF_TRACK:String = ""feathers-toggle-switch-off-track"";

		/**
		 * The default value added to the `nameList` of the on track.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_ON_TRACK:String = ""feathers-toggle-switch-on-track"";

		/**
		 * The default value added to the `nameList` of the thumb.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_THUMB:String = ""feathers-toggle-switch-thumb"";

		/**
		 * @private
		 */
		protected static function defaultThumbFactory():Button
		{
			return new Button();
		}

		/**
		 * @private
		 */
		protected static function defaultOnTrackFactory():Button
		{
			return new Button();
		}

		/**
		 * @private
		 */
		protected static function defaultOffTrackFactory():Button
		{
			return new Button();
		}

		/**
		 * Constructor.
		 */
		public function ToggleSwitch()
		{
			super();
			this.addEventListener(TouchEvent.TOUCH, toggleSwitch_touchHandler);
			this.addEventListener(Event.REMOVED_FROM_STAGE, toggleSwitch_removedFromStageHandler);
		}

		/**
		 * The value added to the `nameList` of the off label. This
		 * variable is `protected` so that sub-classes can customize
		 * the on label name in their constructors instead of using the default
		 * name defined by `DEFAULT_CHILD_NAME_ON_LABEL`.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var onLabelName:String = DEFAULT_CHILD_NAME_ON_LABEL;

		/**
		 * The value added to the `nameList` of the on label. This
		 * variable is `protected` so that sub-classes can customize
		 * the off label name in their constructors instead of using the default
		 * name defined by `DEFAULT_CHILD_NAME_OFF_LABEL`.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var offLabelName:String = DEFAULT_CHILD_NAME_OFF_LABEL;

		/**
		 * The value added to the `nameList` of the on track. This
		 * variable is `protected` so that sub-classes can customize
		 * the on track name in their constructors instead of using the default
		 * name defined by `DEFAULT_CHILD_NAME_ON_TRACK`.
		 *
		 * To customize the on track name without subclassing, see
		 * `customOnTrackName`.
		 *
		 * @see #customOnTrackName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var onTrackName:String = DEFAULT_CHILD_NAME_ON_TRACK;

		/**
		 * The value added to the `nameList` of the off track. This
		 * variable is `protected` so that sub-classes can customize
		 * the off track name in their constructors instead of using the default
		 * name defined by `DEFAULT_CHILD_NAME_OFF_TRACK`.
		 *
		 * To customize the off track name without subclassing, see
		 * `customOffTrackName`.
		 *
		 * @see #customOffTrackName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var offTrackName:String = DEFAULT_CHILD_NAME_OFF_TRACK;

		/**
		 * The value added to the `nameList` of the thumb. This
		 * variable is `protected` so that sub-classes can customize
		 * the thumb name in their constructors instead of using the default
		 * name defined by `DEFAULT_CHILD_NAME_THUMB`.
		 *
		 * To customize the thumb name without subclassing, see
		 * `customThumbName`.
		 *
		 * @see #customThumbName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var thumbName:String = DEFAULT_CHILD_NAME_THUMB;

		/**
		 * The thumb sub-component.
		 */
		protected var thumb:Button;

		/**
		 * The ""on"" text renderer sub-component.
		 */
		protected var onTextRenderer:ITextRenderer;

		/**
		 * The ""off"" text renderer sub-component.
		 */
		protected var offTextRenderer:ITextRenderer;

		/**
		 * The ""on"" track sub-component.
		 */
		protected var onTrack:Button;

		/**
		 * The ""off"" track sub-component.
		 */
		protected var offTrack:Button;

		/**
		 * @private
		 */
		protected var _paddingRight:Number = 0;

		/**
		 * The minimum space, in pixels, between the switch's right edge and the
		 * switch's content.
		 */
		public function get paddingRight():Number
		{
			return this._paddingRight;
		}

		/**
		 * @private
		 */
		public function set paddingRight(value:Number):void
		{
			if(this._paddingRight == value)
			{
				return;
			}
			this._paddingRight = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _paddingLeft:Number = 0;

		/**
		 * The minimum space, in pixels, between the switch's left edge and the
		 * switch's content.
		 */
		public function get paddingLeft():Number
		{
			return this._paddingLeft;
		}

		/**
		 * @private
		 */
		public function set paddingLeft(value:Number):void
		{
			if(this._paddingLeft == value)
			{
				return;
			}
			this._paddingLeft = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _showLabels:Boolean = true;

		/**
		 * Determines if the labels should be drawn. The onTrackSkin and
		 * offTrackSkin backgrounds may include the text instead.
		 */
		public function get showLabels():Boolean
		{
			return _showLabels;
		}

		/**
		 * @private
		 */
		public function set showLabels(value:Boolean):void
		{
			if(this._showLabels == value)
			{
				return;
			}
			this._showLabels = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _showThumb:Boolean = true;

		/**
		 * Determines if the thumb should be displayed. This stops interaction
		 * while still displaying the background.
		 */
		public function get showThumb():Boolean
		{
			return this._showThumb;
		}

		/**
		 * @private
		 */
		public function set showThumb(value:Boolean):void
		{
			if(this._showThumb == value)
			{
				return;
			}
			this._showThumb = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _trackLayoutMode:String = TRACK_LAYOUT_MODE_SINGLE;

		[Inspectable(type=""String"",enumeration=""single,onOff"")]
		/**
		 * Determines how the on and off track skins are positioned and sized.
		 *
		 * @default TRACK_LAYOUT_MODE_SINGLE
		 * @see #TRACK_LAYOUT_MODE_SINGLE
		 * @see #TRACK_LAYOUT_MODE_ON_OFF
		 */
		public function get trackLayoutMode():String
		{
			return this._trackLayoutMode;
		}

		/**
		 * @private
		 */
		public function set trackLayoutMode(value:String):void
		{
			if(this._trackLayoutMode == value)
			{
				return;
			}
			this._trackLayoutMode = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _defaultLabelProperties:Dictionary.<String, Object>;

		/**
		 * The default label properties are a set of key/value pairs to be
		 * passed down to the toggle switch's label text renderers, and it is
		 * used when no specific properties are defined for a specific label
		 * text renderer's current state. The label text renderers are `ITextRenderer`
		 * instances. The available properties depend on which `ITextRenderer`
		 * implementation is returned by `labelFactory`. The most
		 * common implementations are `BitmapFontTextRenderer` and
		 * `TextFieldTextRenderer`.
		 *
		 * @see #labelFactory
		 * @see feathers.core.ITextRenderer
		 * @see feathers.core.BitmapFontTextRenderer
		 * @see feathers.core.TextFieldTextRenderer
		 * @see #onLabelProperties
		 * @see #offLabelProperties
		 * @see #disabledLabelProperties
		 */
		public function get defaultLabelProperties():Dictionary.<String, Object>
		{
			if(!this._defaultLabelProperties)
			{
				this._defaultLabelProperties = new Dictionary.<String, Object>;
			}
			return this._defaultLabelProperties;
		}

		/**
		 * @private
		 */
		public function set defaultLabelProperties(value:Dictionary.<String, Object>):void
		{
			this._defaultLabelProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _disabledLabelProperties:Dictionary.<String, Object>;

		/**
		 * A set of key/value pairs to be passed down to the toggle switch's
		 * label text renderers when the toggle switch is disabled. The label
		 * text renderers are `ITextRenderer` instances. The
		 * available properties depend on which `ITextRenderer`
		 * implementation is returned by `labelFactory`. The most
		 * common implementations are `BitmapFontTextRenderer` and
		 * `TextFieldTextRenderer`.
		 *
		 * @see #labelFactory
		 * @see feathers.core.ITextRenderer
		 * @see feathers.core.BitmapFontTextRenderer
		 * @see feathers.core.TextFieldTextRenderer
		 * @see #defaultLabelProperties
		 */
		public function get disabledLabelProperties():Dictionary.<String, Object>
		{
			if(!this._disabledLabelProperties)
			{
				this._disabledLabelProperties = new Dictionary.<String, Object>;
			}
			return this._disabledLabelProperties;
		}

		/**
		 * @private
		 */
		public function set disabledLabelProperties(value:Dictionary.<String, Object>):void
		{
			this._disabledLabelProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _onLabelProperties:Dictionary.<String, Object>;

		/**
		 * A set of key/value pairs to be passed down to the toggle switch's
		 * ON label text renderer. If `null`, then
		 * `defaultLabelProperties` is used instead. The label text
		 * renderers are `ITextRenderer` instances. The available
		 * properties depend on which `ITextRenderer` implementation
		 * is returned by `labelFactory`. The most common
		 * implementations are `BitmapFontTextRenderer` and
		 * `TextFieldTextRenderer`.
		 *
		 * @see #labelFactory
		 * @see feathers.core.ITextRenderer
		 * @see feathers.core.BitmapFontTextRenderer
		 * @see feathers.core.TextFieldTextRenderer
		 * @see #defaultLabelProperties
		 */
		public function get onLabelProperties():Dictionary.<String, Object>
		{
			if(!this._onLabelProperties)
			{
				this._onLabelProperties = new Dictionary.<String, Object>;
			}
			return this._onLabelProperties;
		}

		/**
		 * @private
		 */
		public function set onLabelProperties(value:Dictionary.<String, Object>):void
		{
			this._onLabelProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _offLabelProperties:Dictionary.<String, Object>;

		/**
		 * A set of key/value pairs to be passed down to the toggle switch's
		 * OFF label text renderer. If `null`, then
		 * `defaultLabelProperties` is used instead. The label text
		 * renderers are `ITextRenderer` instances. The available
		 * properties depend on which `ITextRenderer` implementation
		 * is returned by `labelFactory`. The most common
		 * implementations are `BitmapFontTextRenderer` and
		 * `TextFieldTextRenderer`.
		 *
		 * @see #labelFactory
		 * @see feathers.core.ITextRenderer
		 * @see feathers.core.BitmapFontTextRenderer
		 * @see feathers.core.TextFieldTextRenderer
		 * @see #defaultLabelProperties
		 */
		public function get offLabelProperties():Dictionary.<String, Object>
		{
			if(!this._offLabelProperties)
			{
				this._offLabelProperties = new Dictionary.<String, Object>;
			}
			return this._offLabelProperties;
		}

		/**
		 * @private
		 */
		public function set offLabelProperties(value:Dictionary.<String, Object>):void
		{
			this._offLabelProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _labelAlign:String = LABEL_ALIGN_BASELINE;

		[Inspectable(type=""String"",enumeration=""baseline,middle"")]
		/**
		 * The vertical alignment of the label.
		 */
		public function get labelAlign():String
		{
			return this._labelAlign;
		}

		/**
		 * @private
		 */
		public function set labelAlign(value:String):void
		{
			if(this._labelAlign == value)
			{
				return;
			}
			this._labelAlign = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _labelFactory:Function;

		/**
		 * A function used to instantiate the toggle switch's label text
		 * renderer sub-components. The label text renderers must be instances
		 * of `ITextRenderer`. This factory can be used to change
		 * properties on the label text renderer when it is first created. For
		 * instance, if you are skinning Feathers components without a theme,
		 * you might use this factory to style the label text renderer.
		 *
		 * The factory should have the following function signature:
		 * `function():ITextRenderer`
		 *
		 * @see feathers.core.ITextRenderer
		 * @see feathers.core.FeathersControl#defaultTextRendererFactory
		 */
		public function get labelFactory():Function
		{
			return this._labelFactory;
		}

		/**
		 * @private
		 */
		public function set labelFactory(value:Function):void
		{
			if(this._labelFactory == value)
			{
				return;
			}
			this._labelFactory = value;
			this.invalidate(INVALIDATION_FLAG_TEXT_RENDERER);
		}

		/**
		 * @private
		 */
		protected var onTrackSkinOriginalWidth:Number = NaN;

		/**
		 * @private
		 */
		protected var onTrackSkinOriginalHeight:Number = NaN;

		/**
		 * @private
		 */
		protected var offTrackSkinOriginalWidth:Number = NaN;

		/**
		 * @private
		 */
		protected var offTrackSkinOriginalHeight:Number = NaN;

		/**
		 * @private
		 */
		protected var _isSelected:Boolean = false;

		/**
		 * Indicates if the toggle switch is selected (ON) or not (OFF).
		 */
		public function get isSelected():Boolean
		{
			return this._isSelected;
		}

		/**
		 * @private
		 */
		public function set isSelected(value:Boolean):void
		{
			//normally, we'd check to see if selected actually changed or not
			//but the animation is triggered by the draw cycle, so we always
			//need to invalidate. notice that the event isn't dispatched
			//unless the value changes.
			const oldSelected:Boolean = this._isSelected;
			this._isSelected = value;
			this._isSelectionChangedByUser = false;
			this.invalidate(INVALIDATION_FLAG_SELECTED);
			if(this._isSelected != oldSelected)
			{
				this.dispatchEventWith(Event.CHANGE);
			}
		}

		/**
		 * @private
		 */
		protected var _toggleDuration:Number = 0.15;

		/**
		 * The duration, in seconds, of the animation when the toggle switch
		 * is toggled and animates the position of the thumb.
		 */
		public function get toggleDuration():Number
		{
			return this._toggleDuration;
		}

		/**
		 * @private
		 */
		public function set toggleDuration(value:Number):void
		{
			this._toggleDuration = value;
		}

		/**
		 * @private
		 */
		protected var _toggleEase:Object = Transitions.EASE_OUT;

		/**
		 * The easing function used for toggle animations.
		 */
		public function get toggleEase():Object
		{
			return this._toggleEase;
		}

		/**
		 * @private
		 */
		public function set toggleEase(value:Object):void
		{
			this._toggleEase = value;
		}

		/**
		 * @private
		 */
		protected var _onText:String = ""ON"";

		/**
		 * The text to display in the ON label.
		 */
		public function get onText():String
		{
			return this._onText;
		}

		/**
		 * @private
		 */
		public function set onText(value:String):void
		{
			if(value === null)
			{
				value = """";
			}
			if(this._onText == value)
			{
				return;
			}
			this._onText = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _offText:String = ""OFF"";

		/**
		 * The text to display in the OFF label.
		 */
		public function get offText():String
		{
			return this._offText;
		}

		/**
		 * @private
		 */
		public function set offText(value:String):void
		{
			if(value === null)
			{
				value = """";
			}
			if(this._offText == value)
			{
				return;
			}
			this._offText = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _toggleTween:Tween;

		/**
		 * @private
		 */
		protected var _ignoreTapHandler:Boolean = false;

		/**
		 * @private
		 */
		protected var _touchPointID:int = -1;

		/**
		 * @private
		 */
		protected var _thumbStartX:Number;

		/**
		 * @private
		 */
		protected var _touchStartX:Number;

		/**
		 * @private
		 */
		protected var _isSelectionChangedByUser:Boolean = false;

		/**
		 * @private
		 */
		protected var _onTrackFactory:Function;

		/**
		 * A function used to generate the toggle switch's on track
		 * sub-component. The on track must be an instance of `Button`.
		 * This factory can be used to change properties on the on track when it
		 * is first created. For instance, if you are skinning Feathers
		 * components without a theme, you might use this factory to set skins
		 * and other styles on the on track.
		 *
		 * The function should have the following signature:
		 * `function():Button`
		 *
		 * @see feathers.controls.Button
		 * @see #onTrackProperties
		 */
		public function get onTrackFactory():Function
		{
			return this._onTrackFactory;
		}

		/**
		 * @private
		 */
		public function set onTrackFactory(value:Function):void
		{
			if(this._onTrackFactory == value)
			{
				return;
			}
			this._onTrackFactory = value;
			this.invalidate(INVALIDATION_FLAG_ON_TRACK_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customOnTrackName:String;

		/**
		 * A name to add to the toggle switch's on track sub-component. Typically
		 * used by a theme to provide different skins to different toggle switches.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #onTrackFactory
		 * @see #onTrackProperties
		 */
		public function get customOnTrackName():String
		{
			return this._customOnTrackName;
		}

		/**
		 * @private
		 */
		public function set customOnTrackName(value:String):void
		{
			if(this._customOnTrackName == value)
			{
				return;
			}
			this._customOnTrackName = value;
			this.invalidate(INVALIDATION_FLAG_ON_TRACK_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _onTrackProperties:Dictionary.<String, Object>;

		/**
		 * A set of key/value pairs to be passed down to the toggle switch's on
		 * track sub-component. The on track is a
		 * `feathers.controls.Button` instance.
		 *
		 * If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute `&#64;` notation. For example,
		 * to set the skin on the thumb of a `SimpleScrollBar`
		 * which is in a `Scroller` which is in a `List`,
		 * you can use the following syntax:
		 * `list.scrollerProperties.&#64;verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);`
		 *
		 * Setting properties in a `onTrackFactory` function
		 * instead of using `onTrackProperties` will result in
		 * better performance.
		 * 
		 * @see feathers.controls.Button
		 * @see #onTrackFactory
		 */
		public function get onTrackProperties():Dictionary.<String, Object>
		{
			if(!this._onTrackProperties)
			{
				this._onTrackProperties = new Dictionary.<String, Object>;
			}
			return this._onTrackProperties;
		}

		/**
		 * @private
		 */
		public function set onTrackProperties(value:Dictionary.<String, Object>):void
		{
			if(this._onTrackProperties == value)
			{
				return;
			}
			this._onTrackProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _offTrackFactory:Function;

		/**
		 * A function used to generate the toggle switch's off track
		 * sub-component. The off track must be an instance of `Button`.
		 * This factory can be used to change properties on the off track when it
		 * is first created. For instance, if you are skinning Feathers
		 * components without a theme, you might use this factory to set skins
		 * and other styles on the off track.
		 *
		 * The function should have the following signature:
		 * `function():Button`
		 *
		 * @see feathers.controls.Button
		 * @see #offTrackProperties
		 */
		public function get offTrackFactory():Function
		{
			return this._offTrackFactory;
		}

		/**
		 * @private
		 */
		public function set offTrackFactory(value:Function):void
		{
			if(this._offTrackFactory == value)
			{
				return;
			}
			this._offTrackFactory = value;
			this.invalidate(INVALIDATION_FLAG_OFF_TRACK_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customOffTrackName:String;

		/**
		 * A name to add to the toggle switch's off track sub-component. Typically
		 * used by a theme to provide different skins to different toggle switches.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #offTrackFactory
		 * @see #offTrackProperties
		 */
		public function get customOffTrackName():String
		{
			return this._customOffTrackName;
		}

		/**
		 * @private
		 */
		public function set customOffTrackName(value:String):void
		{
			if(this._customOffTrackName == value)
			{
				return;
			}
			this._customOffTrackName = value;
			this.invalidate(INVALIDATION_FLAG_OFF_TRACK_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _offTrackProperties:Dictionary.<String, Object>;

		/**
		 * A set of key/value pairs to be passed down to the toggle switch's off
		 * track sub-component. The off track is a
		 * `feathers.controls.Button` instance.
		 *
		 * If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute `&#64;` notation. For example,
		 * to set the skin on the thumb of a `SimpleScrollBar`
		 * which is in a `Scroller` which is in a `List`,
		 * you can use the following syntax:
		 * `list.scrollerProperties.&#64;verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);`
		 *
		 * Setting properties in a `offTrackFactory` function
		 * instead of using `offTrackProperties` will result in
		 * better performance.
		 * 
		 * @see feathers.controls.Button
		 * @see #offTrackFactory
		 */
		public function get offTrackProperties():Dictionary.<String, Object>
		{
			if(!this._offTrackProperties)
			{
				this._offTrackProperties = new Dictionary.<String, Object>;
			}
			return this._offTrackProperties;
		}

		/**
		 * @private
		 */
		public function set offTrackProperties(value:Dictionary.<String, Object>):void
		{
			if(this._offTrackProperties == value)
			{
				return;
			}
			this._offTrackProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _thumbFactory:Function;

		/**
		 * A function used to generate the toggle switch's thumb sub-component.
		 * This can be used to change properties on the thumb when it is first
		 * created. For instance, if you are skinning Feathers components
		 * without a theme, you might use `thumbFactory` to set
		 * skins and text styles on the thumb.
		 *
		 * The function should have the following signature:
		 * `function():Button`
		 *
		 * @see #thumbProperties
		 */
		public function get thumbFactory():Function
		{
			return this._thumbFactory;
		}

		/**
		 * @private
		 */
		public function set thumbFactory(value:Function):void
		{
			if(this._thumbFactory == value)
			{
				return;
			}
			this._thumbFactory = value;
			this.invalidate(INVALIDATION_FLAG_THUMB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customThumbName:String;

		/**
		 * A name to add to the toggle switch's thumb sub-component. Typically
		 * used by a theme to provide different skins to different toggle switches.
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see #thumbFactory
		 * @see #thumbProperties
		 */
		public function get customThumbName():String
		{
			return this._customThumbName;
		}

		/**
		 * @private
		 */
		public function set customThumbName(value:String):void
		{
			if(this._customThumbName == value)
			{
				return;
			}
			this._customThumbName = value;
			this.invalidate(INVALIDATION_FLAG_THUMB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _thumbProperties:Dictionary.<String, Object>;

		/**
		 * A set of key/value pairs to be passed down to the toggle switch's
		 * thumb sub-component. The thumb is a
		 * `feathers.controls.Button` instance.
		 *
		 * If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute `&#64;` notation. For example,
		 * to set the skin on the thumb of a `SimpleScrollBar`
		 * which is in a `Scroller` which is in a `List`,
		 * you can use the following syntax:
		 * `list.scrollerProperties.&#64;verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);`
		 *
		 * Setting properties in a `thumbFactory` function instead
		 * of using `thumbProperties` will result in better
		 * performance.
		 * 
		 * @see feathers.controls.Button
		 * @see #thumbFactory
		 */
		public function get thumbProperties():Dictionary.<String, Object>
		{
			if(!this._thumbProperties)
			{
				this._thumbProperties = new Dictionary.<String, Object>;
			}
			return this._thumbProperties;
		}

		/**
		 * @private
		 */
		public function set thumbProperties(value:Dictionary.<String, Object>):void
		{
			if(this._thumbProperties == value)
			{
				return;
			}
			this._thumbProperties = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		override protected function draw():void
		{
			const selectionInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SELECTED);
			const stylesInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STYLES);
			var sizeInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SIZE);
			const stateInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STATE);
			const focusInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_FOCUS);
			const textRendererInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_TEXT_RENDERER);
			const thumbFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_THUMB_FACTORY);
			const onTrackFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_ON_TRACK_FACTORY);
			const offTrackFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_OFF_TRACK_FACTORY);

			if(thumbFactoryInvalid)
			{
				this.createThumb();
			}

			if(onTrackFactoryInvalid)
			{
				this.createOnTrack();
			}

			this.createOrDestroyOffTrackIfNeeded(offTrackFactoryInvalid);

			if(textRendererInvalid)
			{
				this.createLabels();
			}

			if(stylesInvalid)
			{
				this.refreshOnLabelStyles();
				this.refreshOffLabelStyles();
			}

			if(thumbFactoryInvalid || stylesInvalid)
			{
				this.refreshThumbStyles();
			}
			if(onTrackFactoryInvalid || stylesInvalid)
			{
				this.refreshOnTrackStyles();
			}
			if((offTrackFactoryInvalid || stylesInvalid) && this.offTrack)
			{
				this.refreshOffTrackStyles();
			}

			if(thumbFactoryInvalid || stateInvalid)
			{
				this.thumb.isEnabled = this._isEnabled;
			}
			if(onTrackFactoryInvalid || stateInvalid)
			{
				this.onTrack.isEnabled = this._isEnabled;
			}
			if((offTrackFactoryInvalid || stateInvalid) && this.offTrack)
			{
				this.offTrack.isEnabled = this._isEnabled;
			}

			sizeInvalid = this.autoSizeIfNeeded() || sizeInvalid;

			if(sizeInvalid || stylesInvalid || selectionInvalid)
			{
				this.updateSelection();
			}

			if(stylesInvalid || sizeInvalid || stateInvalid || selectionInvalid)
			{
				this.layoutChildren();
			}

			if(sizeInvalid || focusInvalid)
			{
				this.refreshFocusIndicator();
			}
		}

		/**
		 * @private
		 */
		protected function autoSizeIfNeeded():Boolean
		{
			if(isNaN(this.onTrackSkinOriginalWidth) || isNaN(this.onTrackSkinOriginalHeight))
			{
				this.onTrack.validate();
				this.onTrackSkinOriginalWidth = this.onTrack.width;
				this.onTrackSkinOriginalHeight = this.onTrack.height;
			}
			if(this.offTrack)
			{
				if(isNaN(this.offTrackSkinOriginalWidth) || isNaN(this.offTrackSkinOriginalHeight))
				{
					this.offTrack.validate();
					this.offTrackSkinOriginalWidth = this.offTrack.width;
					this.offTrackSkinOriginalHeight = this.offTrack.height;
				}
			}

			const needsWidth:Boolean = isNaN(this.explicitWidth);
			const needsHeight:Boolean = isNaN(this.explicitHeight);
			if(!needsWidth && !needsHeight)
			{
				return false;
			}
			this.thumb.validate();
			var newWidth:Number = this.explicitWidth;
			var newHeight:Number = this.explicitHeight;
			if(needsWidth)
			{
				if(this.offTrack)
				{
					newWidth = Math.min(this.onTrackSkinOriginalWidth, this.offTrackSkinOriginalWidth) + this.thumb.width / 2;
				}
				else
				{
					newWidth = this.onTrackSkinOriginalWidth;
				}
			}
			if(needsHeight)
			{
				if(this.offTrack)
				{
					newHeight = Math.max(this.onTrackSkinOriginalHeight, this.offTrackSkinOriginalHeight);
				}
				else
				{
					newHeight = this.onTrackSkinOriginalHeight;
				}
			}
			return this.setSizeInternal(newWidth, newHeight, false);
		}

		/**
		 * @private
		 */
		protected function createThumb():void
		{
			if(this.thumb)
			{
				this.thumb.removeFromParent(true);
				this.thumb = null;
			}

			const factory:Function = this._thumbFactory != null ? this._thumbFactory : defaultThumbFactory;
			const thumbName:String = this._customThumbName != null ? this._customThumbName : this.thumbName;
			this.thumb = Button(factory.call());
			this.thumb.nameList.add(thumbName);
			this.thumb.keepDownStateOnRollOut = true;
			this.thumb.addEventListener(TouchEvent.TOUCH, thumb_touchHandler);
			this.addChild(this.thumb);
		}

		/**
		 * @private
		 */
		protected function createOnTrack():void
		{
			if(this.onTrack)
			{
				this.onTrack.removeFromParent(true);
				this.onTrack = null;
			}

			const factory:Function = this._onTrackFactory != null ? this._onTrackFactory : defaultOnTrackFactory;
			const onTrackName:String = this._customOnTrackName != null ? this._customOnTrackName : this.onTrackName;
			this.onTrack = Button(factory.call());
			this.onTrack.nameList.add(onTrackName);
			this.onTrack.keepDownStateOnRollOut = true;
			this.addChildAt(this.onTrack, 0);
		}

		/**
		 * @private
		 */
		protected function createOrDestroyOffTrackIfNeeded(offTrackFactoryInvalid:Boolean):void
		{
			if(this._trackLayoutMode == TRACK_LAYOUT_MODE_ON_OFF)
			{
				if(!offTrackFactoryInvalid)
				{
					return;
				}
				if(this.offTrack)
				{
					this.offTrack.removeFromParent(true);
					this.offTrack = null;
				}
				const factory:Function = this._offTrackFactory != null ? this._offTrackFactory : defaultOffTrackFactory;
				const offTrackName:String = this._customOffTrackName != null ? this._customOffTrackName : this.offTrackName;
				this.offTrack = Button(factory.call());
				this.offTrack.nameList.add(offTrackName);
				this.offTrack.keepDownStateOnRollOut = true;
				this.addChildAt(this.offTrack, 1);
			}
			else if(this.offTrack) //single
			{
				this.offTrack.removeFromParent(true);
				this.offTrack = null;
			}
		}

		/**
		 * @private
		 */
		protected function createLabels():void
		{
			if(this.offTextRenderer)
			{
				this.removeChild(DisplayObject(this.offTextRenderer), true);
				this.offTextRenderer = null;
			}
			if(this.onTextRenderer)
			{
				this.removeChild(DisplayObject(this.onTextRenderer), true);
				this.onTextRenderer = null;
			}

			const index:int = this.getChildIndex(this.thumb);
			const factory:Function = this._labelFactory != null ? this._labelFactory : FeathersControl.defaultTextRendererFactory;
			this.offTextRenderer = ITextRenderer(factory.call());
			this.offTextRenderer.nameList.add(this.offLabelName);
			if(this.offTextRenderer is FeathersControl)
			{
				FeathersControl(this.offTextRenderer).clipRect = new Rectangle();
			}
			this.addChildAt(DisplayObject(this.offTextRenderer), index);

			this.onTextRenderer = ITextRenderer(factory.call());
			this.onTextRenderer.nameList.add(this.onLabelName);
			if(this.onTextRenderer is FeathersControl)
			{
				FeathersControl(this.onTextRenderer).clipRect = new Rectangle();
			}
			this.addChildAt(DisplayObject(this.onTextRenderer), index);
		}

		/**
		 * @private
		 */
		protected function layoutChildren():void
		{
			this.thumb.validate();
			this.thumb.y = (this.actualHeight - this.thumb.height) / 2;

			const maxLabelWidth:Number = Math.max(0, this.actualWidth - this.thumb.width - this._paddingLeft - this._paddingRight);
			var totalLabelHeight:Number = Math.max(this.onTextRenderer.height, this.offTextRenderer.height);
			var labelHeight:Number;
			if(this._labelAlign == LABEL_ALIGN_MIDDLE)
			{
				labelHeight = totalLabelHeight;
			}
			else //baseline
			{
				labelHeight = Math.max(this.onTextRenderer.baseline, this.offTextRenderer.baseline);
			}

			if(this.onTextRenderer is FeathersControl)
			{
				var clipRect:Rectangle = FeathersControl(this.onTextRenderer).clipRect;
				clipRect.width = maxLabelWidth;
				clipRect.height = totalLabelHeight;
				FeathersControl(this.onTextRenderer).clipRect = clipRect;
			}

			this.onTextRenderer.y = (this.actualHeight - labelHeight) / 2;

			if(this.offTextRenderer is FeathersControl)
			{
				clipRect = FeathersControl(this.offTextRenderer).clipRect;
				clipRect.width = maxLabelWidth;
				clipRect.height = totalLabelHeight;
				FeathersControl(this.offTextRenderer).clipRect = clipRect;
			}

			this.offTextRenderer.y = (this.actualHeight - labelHeight) / 2;

			this.layoutTracks();
		}

		/**
		 * @private
		 */
		protected function layoutTracks():void
		{
			const maxLabelWidth:Number = Math.max(0, this.actualWidth - this.thumb.width - this._paddingLeft - this._paddingRight);
			const thumbOffset:Number = this.thumb.x - this._paddingLeft;

			var onScrollOffset:Number = maxLabelWidth - thumbOffset - (maxLabelWidth - this.onTextRenderer.width) / 2;
			if(this.onTextRenderer is FeathersControl)
			{
				const displayOnLabelRenderer:FeathersControl = FeathersControl(this.onTextRenderer);
				var currentClipRect:Rectangle = displayOnLabelRenderer.clipRect;
				currentClipRect.x = onScrollOffset
				displayOnLabelRenderer.clipRect = currentClipRect;
			}
			this.onTextRenderer.x = this._paddingLeft - onScrollOffset;

			var offScrollOffset:Number = -thumbOffset - (maxLabelWidth - this.offTextRenderer.width) / 2;
			if(this.offTextRenderer is FeathersControl)
			{
				const displayOffLabelRenderer:FeathersControl = FeathersControl(this.offTextRenderer);
				currentClipRect = displayOffLabelRenderer.clipRect;
				currentClipRect.x = offScrollOffset
				displayOffLabelRenderer.clipRect = currentClipRect;
			}
			this.offTextRenderer.x = this.actualWidth - this._paddingRight - maxLabelWidth - offScrollOffset;

			if(this._trackLayoutMode == TRACK_LAYOUT_MODE_ON_OFF)
			{
				this.layoutTrackWithOnOff();
			}
			else
			{
				this.layoutTrackWithSingle();
			}
		}

		/**
		 * @private
		 */
		protected function updateSelection():void
		{
			this.thumb.validate();

			var xPosition:Number = this._paddingLeft;
			if(this._isSelected)
			{
				xPosition = this.actualWidth - this.thumb.width - this._paddingRight;
			}

			//stop the tween, no matter what
			if(this._toggleTween)
			{
				Loom2D.juggler.remove(this._toggleTween);
				this._toggleTween = null;
			}

			if(this._isSelectionChangedByUser)
			{
				this._toggleTween = new Tween(this.thumb, this._toggleDuration, this._toggleEase);
				this._toggleTween.animate(""x"", xPosition);
				this._toggleTween.onUpdate = selectionTween_onUpdate;
				this._toggleTween.onComplete = selectionTween_onComplete;
				Loom2D.juggler.add(this._toggleTween);
			}
			else
			{
				this.thumb.x = xPosition;
			}
			this._isSelectionChangedByUser = false;
		}

		/**
		 * @private
		 */
		protected function refreshOnLabelStyles():void
		{
			//no need to style the label field if there's no text to display
			if(!this._showLabels || !this._showThumb)
			{
				this.onTextRenderer.visible = false;
				return;
			}

			var properties:PropertyProxy;
			if(!this._isEnabled)
			{
				properties = this._disabledLabelProperties;
			}
			if(!properties && this._onLabelProperties)
			{
				properties = this._onLabelProperties;
			}
			if(!properties)
			{
				properties = this._defaultLabelProperties;
			}

			this.onTextRenderer.text = this._onText;
			if(properties)
			{
				Dictionary.mapToObject(properties, onTextRenderer);
			}
			this.onTextRenderer.validate();
			this.onTextRenderer.visible = true;
		}

		/**
		 * @private
		 */
		protected function refreshOffLabelStyles():void
		{
			//no need to style the label field if there's no text to display
			if(!this._showLabels || !this._showThumb)
			{
				this.offTextRenderer.visible = false;
				return;
			}

			var properties:PropertyProxy;
			if(!this._isEnabled)
			{
				properties = this._disabledLabelProperties;
			}
			if(!properties && this._offLabelProperties)
			{
				properties = this._offLabelProperties;
			}
			if(!properties)
			{
				properties = this._defaultLabelProperties;
			}

			this.offTextRenderer.text = this._offText;
			if(properties)
			{
				Dictionary.mapToObject(properties, onTextRenderer);
			}
			this.offTextRenderer.validate();
			this.offTextRenderer.visible = true;
		}

		/**
		 * @private
		 */
		protected function refreshThumbStyles():void
		{
			Dictionary.mapToObject(_thumbProperties, thumb);
			this.thumb.visible = this._showThumb;
		}

		/**
		 * @private
		 */
		protected function refreshOnTrackStyles():void
		{
			Dictionary.mapToObject(_onTrackProperties, onTrack);
		}

		/**
		 * @private
		 */
		protected function refreshOffTrackStyles():void
		{
			if(!this.offTrack)
			{
				return;
			}
			Dictionary.mapToObject(_offTrackProperties, offTrack);
		}

		/**
		 * @private
		 */
		protected function layoutTrackWithOnOff():void
		{
			this.onTrack.x = 0;
			this.onTrack.y = 0;
			this.onTrack.width = this.thumb.x + this.thumb.width / 2;
			this.onTrack.height = this.actualHeight;

			this.offTrack.x = this.onTrack.width;
			this.offTrack.y = 0;
			this.offTrack.width = this.actualWidth - this.offTrack.x;
			this.offTrack.height = this.actualHeight;
		}

		/**
		 * @private
		 */
		protected function layoutTrackWithSingle():void
		{
			this.onTrack.x = 0;
			this.onTrack.y = 0;
			this.onTrack.width = this.actualWidth;
			this.onTrack.height = this.actualHeight;
		}

		/**
		 * @private
		 */
		protected function childProperties_onChange(proxy:PropertyProxy, name:Object):void
		{
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected function toggleSwitch_removedFromStageHandler(event:Event):void
		{
			this._touchPointID = -1;
		}

		/**
		 * @private
		 */
		override protected function focusInHandler(event:Event):void
		{
			super.focusInHandler(event);
			this.stage.addEventListener(KeyboardEvent.KEY_DOWN, stage_keyDownHandler);
			this.stage.addEventListener(KeyboardEvent.KEY_UP, stage_keyUpHandler);
		}

		/**
		 * @private
		 */
		override protected function focusOutHandler(event:Event):void
		{
			super.focusOutHandler(event);
			this.stage.removeEventListener(KeyboardEvent.KEY_DOWN, stage_keyDownHandler);
			this.stage.removeEventListener(KeyboardEvent.KEY_UP, stage_keyUpHandler);
		}

		/**
		 * @private
		 */
		protected function toggleSwitch_touchHandler(event:TouchEvent):void
		{
			if(this._ignoreTapHandler)
			{
				this._ignoreTapHandler = false;
				return;
			}
			if(!this._isEnabled)
			{
				this._touchPointID = -1;
				return;
			}

			const touches:Vector.<Touch> = event.getTouches(this, null, HELPER_TOUCHES_VECTOR);
			if(touches.length == 0)
			{
				return;
			}
			var touch:Touch;
			for each(var currentTouch:Touch in touches)
			{
				if((this._touchPointID >= 0 && currentTouch.id == this._touchPointID) ||
					(this._touchPointID < 0 && currentTouch.phase == TouchPhase.ENDED))
				{
					touch = currentTouch;
					break;
				}
			}
			if(!touch || touch.phase != TouchPhase.ENDED)
			{
				HELPER_TOUCHES_VECTOR.length = 0;
				return;
			}

			this._touchPointID = -1;
			touch.getLocation(this.stage, HELPER_POINT);
			if(this.contains(this.stage.hitTest(HELPER_POINT, true)))
			{
				this.isSelected = !this._isSelected;
				this._isSelectionChangedByUser = true;
			}
			HELPER_TOUCHES_VECTOR.length = 0;
		}

		/**
		 * @private
		 */
		protected function thumb_touchHandler(event:TouchEvent):void
		{
			if(!this._isEnabled)
			{
				return;
			}
			const touches:Vector.<Touch> = event.getTouches(this.thumb, null, HELPER_TOUCHES_VECTOR);
			if(touches.length == 0)
			{
				return;
			}
			if(this._touchPointID >= 0)
			{
				var touch:Touch;
				for each(var currentTouch:Touch in touches)
				{
					if(currentTouch.id == this._touchPointID)
					{
						touch = currentTouch;
						break;
					}
				}
				if(!touch)
				{
					HELPER_TOUCHES_VECTOR.length = 0;
					return;
				}
				touch.getLocation(this, HELPER_POINT);
				const trackScrollableWidth:Number = this.actualWidth - this._paddingLeft - this._paddingRight - this.thumb.width;
				if(touch.phase == TouchPhase.MOVED)
				{
					const xOffset:Number = HELPER_POINT.x - this._touchStartX;
					const xPosition:Number = Math.min(Math.max(this._paddingLeft, this._thumbStartX + xOffset), this._paddingLeft + trackScrollableWidth);
					this.thumb.x = xPosition;
					this.layoutTracks();
				}
				else if(touch.phase == TouchPhase.ENDED)
				{
					const inchesMoved:Number = Math.abs(HELPER_POINT.x - this._touchStartX) / DeviceCapabilities.dpi;
					if(inchesMoved > MINIMUM_DRAG_DISTANCE)
					{
						this._touchPointID = -1;
						this.isSelected = this.thumb.x > (this._paddingLeft + trackScrollableWidth / 2);
						this._isSelectionChangedByUser = true;
						this._ignoreTapHandler = true;
					}
				}
			}
			else
			{
				for each(touch in touches)
				{
					if(touch.phase == TouchPhase.BEGAN)
					{
						touch.getLocation(this, HELPER_POINT);
						this._touchPointID = touch.id;
						this._thumbStartX = this.thumb.x;
						this._touchStartX = HELPER_POINT.x;
						break;
					}
				}
			}
			HELPER_TOUCHES_VECTOR.length = 0;
		}

		/**
		 * @private
		 */
		protected function stage_keyDownHandler(event:KeyboardEvent):void
		{
			if(event.keyCode == Keyboard.ESCAPE)
			{
				this._touchPointID = -1;
			}
			if(this._touchPointID >= 0 || event.keyCode != Keyboard.SPACE)
			{
				return;
			}
			this._touchPointID = int.MAX_VALUE;
		}

		/**
		 * @private
		 */
		protected function stage_keyUpHandler(event:KeyboardEvent):void
		{
			if(this._touchPointID != int.MAX_VALUE || event.keyCode != Keyboard.SPACE)
			{
				return;
			}
			this._touchPointID = -1;
			this.isSelected = !this._isSelected;
		}

		/**
		 * @private
		 */
		protected function selectionTween_onUpdate():void
		{
			this.layoutTracks();
		}

		/**
		 * @private
		 */
		protected function selectionTween_onComplete():void
		{
			this._toggleTween = null;
		}
	}
}",12092,False,2478.325086975296,median
"/*
 * DESCRIPTION
 * 
 * This device can toggle two relays, and thus two electric locks. These relays can be controlled via the Candle Controller, but also via SMS (if you want).
 * The SMS function is password protected: you have to send a password to switch the relay. Access can also be limited to only certain mobile phone numbers, and only certain moments (by toggling the Mobile control switch).
 * 
 * If you send an SMS without the password, it will be shown as the Incoming SMS. This can be used to automate other things in your home. For example, you could create a rule that when the system receices an SMS with ""purifier on"" in it, the air purifier will turn on.
 * 
 * This way you can control smart devices in your home even if it/Candle is not connected to the internet.
 * 
 * If data transmission is disabled, you can change the state of the lock via SMS or the pushbutton without the new state being sent to the controller.
 * 
 * SETTINGS */ 

// It's important to change these to your own phone number(s). When the device starts up it will always start with these values.
// You will also be able to change this via your controller later, but in case no connection to the controller can be established it's a good idea to enter your phonenumber here.
char phone1[15] = ""+031612345678"";                  // Phone number of user #1. This is the main number to which status updates will be sent.
char phone2[15] = ""+031612345678"";                  // Phone number of user #2 (optional). If there is no second user, set it the same number as user #1.

char rotatingPassword1[26] = ""door1"";               // Door 1 password. If the device is powered up and can't reconnect to the home network, then this will be the fallback password. Maximum length is 25 characters.
#define DOOR1_SELF_LOCKING                          // Self locking? Should door number one automatically re-lock itself after a short amount of time?
char rotatingPassword2[26] = ""door2"";               // Door 2 password. If the device is powered up and can't reconnect to the home network, then this will be the fallback password. Maximum length is 25 characters.
//#define DOOR2_SELF_LOCKING                        // Self locking? Should door number two automatically re-lock itself after a short amount of time?

#define SELF_LOCKING_DELAY 5                        // Self locking delay. If a door is self-locking, how many seconds before it should re-lock?

//#define HAS_BUTTONS                                 // Have you attached buttons? You can toggle the state of each lock with a push button if you want. If you want this feature, even if you only want it for one, you have to attach two buttons, one for each door.

#define APN_URL ""internet""                          // APN Name. The APN URL from your mobile provider. Check your provider website for the precise settings.
#define APN_USERNAME """"                             // APN Login. The APN username from your mobile provider. You can try leaving this and the password empty.
#define APN_PASSWORD """"                             // APN Password. The APN password from your mobile provider.

//#define SEND_SMS_EVERY_49_DAYS                    // Send SMS every 49 days. If you are using a prepaid simcard, you may have to send an SMS once in a while to stop your simcard from getting disabled. This function tries sending an SMS to you once every 49 days.

#define ALLOW_CONNECTING_TO_NETWORK                 // Connect wirelessly. Is this device allowed to connect to the network? For privacy or security reasons you may prefer a stand-alone device. If you do allow the device to connect, you can connect a button to switch the transmission of data or off.

#define RF_NANO                                     // RF-Nano. Check this box if you are using the RF-Nano Arduino, which has a built in radio. The Candle project uses the RF-Nano.


/* END OF SETTINGS
 *  
 *  
 * LYCAMOBILE
 * APN: data.lycamobile.nl
 * Username: lmnl
 * Password: plus
 * CUSD command to get phone number: *102#
 * 
 * LEBARA
 * APN: internet
 * No username or password are required, so they can be empty.
 *  
*/

//#define DEBUG                                     // Display debug information in the serial output.
//#define MY_DEBUG                                  // Enable MySensors debug output to the serial monitor, so you can check if the radio is working ok.
//#define JESSE                                     // Enables the special features for Jesse Howard's Candle prototypes.


// Enable and select the attached radio type
#define MY_RADIO_RF24                               // This is a common and simple radio used with MySensors. Downside is that it uses the same frequency space as WiFi.
//#define MY_RADIO_NRF5_ESB                         // This is a new type of device that is arduino and radio all in one. Currently not suitable for beginners yet.
//#define MY_RADIO_RFM69                            // This is an open source radio on the 433mhz frequency. Great range and built-in encryption, but more expensive and little more difficult to connect.
//#define MY_RADIO_RFM95                            // This is a LoRaWan radio, which can have a range of 10km.

// MySensors: Choose your desired radio power level. High power can cause issues on cheap Chinese NRF24 radio's.
//#define MY_RF24_PA_LEVEL RF24_PA_MIN
//#define MY_RF24_PA_LEVEL RF24_PA_LOW
//#define MY_RF24_PA_LEVEL RF24_PA_HIGH
#define MY_RF24_PA_LEVEL RF24_PA_MAX

// Mysensors security
//#define DEBUG_SIGNING
#define MY_ENCRYPTION_SIMPLE_PASSWD ""changeme""      // Be aware, the length of the password has an effect on memory use.
//#define MY_SECURITY_SIMPLE_PASSWD ""changeme""      // Be aware, the length of the password has an effect on memory use.
//#define MY_SIGNING_SOFT_RANDOMSEED_PIN A7         // Setting a pin to pickup random electromagnetic noise helps make encryption more secure.

// Mysensors advanced settings
#define MY_TRANSPORT_WAIT_READY_MS 10000            // Try connecting for 10 seconds. Otherwise just continue.
//#define MY_RF24_CHANNEL 100                       // In EU the default channel 76 overlaps with wifi, so you could try using channel 100. But you will have to set this up on every device, and also on the controller.
#define MY_RF24_DATARATE RF24_1MBPS                 // Slower datarate makes the network more stable
//#define MY_RF24_DATARATE RF24_250KBPS             // Slower datarate increases wireless range
//#define MY_NODE_ID 10                             // Giving a node a manual ID can in rare cases fix connection issues.
//#define MY_PARENT_NODE_ID 0                       // Fixating the ID of the gatewaynode can in rare cases fix connection issues.
//#define MY_PARENT_NODE_IS_STATIC                  // Used together with setting the parent node ID. Daking the controller ID static can in rare cases fix connection issues.
#define MY_SPLASH_SCREEN_DISABLED                   // Saves a little memory.
//#define MY_DISABLE_RAM_ROUTING_TABLE_FEATURE      // Saves a little memory.


// MySensors devices form a mesh network by passing along messages for each other. Do you want this node to also be a repeater?
#define MY_REPEATER_FEATURE                         // Add or remove the two slashes at the beginning of this line to select if you want this sensor to act as a repeater for other sensors. If this node is on battery power, you probably shouldn't enable this.

// Define Node ID
//#define MY_NODE_ID 15
//#define MY_PARENT_NODE_ID 0
//#define MY_PARENT_NODE_IS_STATIC


// PINS
#define GSM_RECEIVE_PIN 3                           // Connect to U_TXD on the GSM module
#define GSM_TRANSMIT_PIN 4                          // Connect to U_RXD on the GSM module
#define RELAY1_PIN 5                                // Relay 1 pin number (use this on a door that needs a short pulse to open).
#define RELAY2_PIN 6                                // Relay 2 pin number (use this on a door that can be set to locked or unlocked mode, for example with a solenoid.).


#ifdef JESSE                                        // For the Candle prototype by Jesse Howard
#define TOGGLE_FAKE_DATA_PIN A3
#define TOP_MOTOR_SWITCH_PIN A1
#define BOTTOM_MOTOR_SWITCH_PIN A2
#define MOTOR_FORWARD_PIN 7
#define MOTOR_BACKWARD_PIN 8
#else
#define BUTTON1_PIN A0                              // Manual momentary button for door 1.
#define BUTTON2_PIN A1                              // Manual momentary button for door 2.
#endif

#ifdef RF_NANO
// If you are using an RF-Nano, you have to switch CE and CS pins.
#define MY_RF24_CS_PIN 9                            // Used by the MySensors library.
#define MY_RF24_CE_PIN 10                           // Used by the MySensors library.
#endif


// THESE VALUES CAN BE CHANGED

#define LOOP_DURATION 1000                          // The main loop runs every x milliseconds. This main loop starts the modem, and from then on periodically requests the password.
#define SECONDS_BETWEEN_HEARTBEAT_TRANSMISSION 120  // The smart lock might not send any data for a very long time if it isn't used. Sending a heartbeat tells the controller: I'm still there.
#define MAXIMUMTIMEOUTS 30                          // How often the network may fail before we conclude there is a connection problem.

#define LOCKED 1                                    // This makes it easier to understand what the code is doing. It allows the code to say ""LOCKED"" instead of ""1"".
#define UNLOCKED 0                                  // This makes it easier to understand what the code is doing. It allows the code to say ""UNLOCKED"" instead of ""0"".

#define RELAY_LOCKED 1                              // Some relays work in reverse. This allows you to choose if a 'lock' signal should send a HIGH or LOW signal to your relay
#define RELAY_UNLOCKED 0                            // Some relays work in reverse. This allows you to choose if an 'unlock' signal should send a HIGH or LOW signal to your relay.

#define EEPROM_STORAGE_START 512                    // From which position the eeprom can safely be used as storage without overwriting MySensors encryption data. Another option would be to use EEPROM_LOCAL_CONFIG_ADDRESS, a MySensors feature.


// Libraries
#include <MySensors.h>                              // The MySensors library that allows devices to communicate and form networks.
#include <avr/pgmspace.h>
#include <EEPROM.h>                                 // Allows for storing data on the Arduino itself, like a mini hard-drive.

// Software serial
#define _SS_MAX_RX_BUFF 255                         // The size of the software serial buffer
#define SERIAL_LINE_LENGTH 128                      // The maximum length that a line from the GSM modem can be.
#include <SoftwareSerial.h>                         // A software library for serial communication. In this case we use it to talk to the GSM modem. Currently not used because of a strange issue.
SoftwareSerial modem(GSM_RECEIVE_PIN,GSM_TRANSMIT_PIN); // Receive pin (RX), transmit pin (TX)



char serial_line[SERIAL_LINE_LENGTH];                // Holds the line received from the modem.

// MySensors children
#define DEVICE_STATUS_ID 0                          // The first 'child' of this device is a text field that contains status updates.
#define SMS_CHILD_ID 1                              // This field is used to tell the controller what text was in the sms. Useful for automation of other things that you want to trigger using an SMS.
#define SENDSMS_CHILD_ID 2                          // If this string is modified at the controller, a test sms will be sent. Useful to keep a simcard alive (must send at least one SMS every X months usually).
#define BUTTON_CHILD_ID 3                           // Set button ID number on this node.
#define TRANSMISSION_STATE_CHILD_ID 4               // The child ID of the data transmission switch.
#define SMS_CONTROL_ID 5                            // Toggle whether SMS is allowed to control the lock.

#define ROTATING_PASSWORD1_ID 10                    // Set password ID number on this node that can be set from outside.
#define ROTATING_PASSWORD2_ID 36                    // Set password ID number on this node that can be set from outside.
#define PHONENUMBER1_ID 120                         // If (part of) a phonenumber is given, only phonenumbers that have that part will be allowed to open the lock. E.g. ""+31"" only allows Dutch numbers. ""+3161482375"" would only allow that one number.
#define PHONENUMBER2_ID 135                         // If (part of) a phonenumber is given, only phonenumbers that have that part will be allowed to open the lock. E.g. ""+31"" only allows Dutch numbers. ""+3161482375"" would only allow that one number.

#define RELAY1_CHILD_ID 210                         // Set switch ID number on this node. Door 1.
#define RELAY2_CHILD_ID 211                         // Set switch ID number on this node. Door 2. This needs to be 1 higher than relay 1.

MyMessage text_message(DEVICE_STATUS_ID, V_TEXT);   // Sets up the message format that we'll be sending to the MySensors gateway later. The first part is the ID of the specific sensor module on this node. The second part tells the gateway what kind of data to expect.
MyMessage relay_message(TRANSMISSION_STATE_CHILD_ID, V_STATUS); // A generic boolean state message.
MyMessage lock_message(RELAY1_CHILD_ID, V_STATUS); // A message to send the state of locks. Was 'V_LOCK_STATUS', but this is a currently a read-only property.


// General variables
#define DOOR_COUNT 2                                // How many electric locks are attached.
#define RADIO_DELAY 100                             // Milliseconds delay betweeen radio signals. This gives the radio some breathing room.
boolean incomingSMS = 0;                            // Used in flow control when processing an SMS.
boolean waitingForResponse = false;                 // Used to check if the connection to the controller is ok. If we are still waiting by the next time a password is requested, something is fishy.
boolean send_all_values = 1;
boolean processing_line = 0;

boolean desired_door_states[DOOR_COUNT];            // An array that holds the desired door states. These are turned into:
boolean actualDoorStates[DOOR_COUNT];               // An array that holds the actual door states.

const char unlockedMessage[] PROGMEM = { ""  unlocked"" }; // This construction saves some memory. Only the first character has to be changed to create a message to send via SMS, such as ""1 locked"" or ""2 unlocked"".s
const char lockedMessage[] PROGMEM = { ""  locked"" }; // This construction saves some memory.
const char passwordMessage[] PROGMEM = { ""Door   password"" }; // This construction saves some memory.

#define WORK_STRING_SIZE 26                         // Length of an array that holds various strings.
char work_string[WORK_STRING_SIZE];                 // Creates an array that will hold various strings.


// MODEM STATES
#define MODEM_BUFFER_EMPTY 0                        // These three states are used to avoid sending the modem commands while it's still sending them to the Arduino.
#define WAITING_FOR_RESPONSE_FROM_MODEM 1
#define MODEM_PROCESSING_RESPONSE 2



byte modem_state = MODEM_BUFFER_EMPTY;
boolean modem_booted = false;


// DATA TRANSMISSION TOGGLE
boolean transmission_state = true;
boolean desired_transmission_state = true;

boolean sms_control_state = true;
boolean desired_sms_control_state = true;

boolean store_to_eeprom = false;
boolean send_sms = false;

#ifdef DEBUG
// A small funtion that can tell you how much ram is left.
int freeRam () {
  extern int __heap_start, *__brkval; 
  int v; 
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
}
// via https://playground.arduino.cc/Code/AvailableMemory
#endif




// The before function is run very early on. This makes it great for quickly changing pin settings.
void before()
{
  Serial.begin(115200);
  Serial.println(F(""Hello world, I am a door lock.""));

  memset(desired_door_states,0,sizeof(desired_door_states));
  memset(actualDoorStates,0,sizeof(actualDoorStates));

  for( byte checkingDoor = 0; checkingDoor < DOOR_COUNT; checkingDoor++ ){
    //Serial.print(F(""BUTTON1_PIN + checkingDoor = "")); Serial.println(BUTTON1_PIN + checkingDoor);
    pinMode(RELAY1_PIN + checkingDoor, OUTPUT);     // Set all relay pins to be output.
     // Set the button pins as input.
    //pinMode(BUTTON1_PIN + checkingDoor, INPUT);   // Set the button pins as input.
    byte possibleDesiredState = EEPROM.read(EEPROM_STORAGE_START + RELAY1_CHILD_ID + checkingDoor);
    
    if( possibleDesiredState == 0 || possibleDesiredState == 1 ){ // If the eeprom has the number '255' here, then it clearly hasn't been set to hold a desired value before, and we should not use it.
      //Serial.println(""Found useable state in eeprom"");
      desired_door_states[checkingDoor] = possibleDesiredState;
      
      if( possibleDesiredState == LOCKED){          // This may seem complicated. The numerical state that represents 'locked' in the interface could be different from what the relay conciders locked. For example, 1 could be locked in the interface, but unlocked for the relay. And vice-versa. This construction deals with that possibility.
        digitalWrite(RELAY1_PIN + checkingDoor, RELAY_LOCKED);
      }
      if( possibleDesiredState == UNLOCKED){
        digitalWrite(RELAY1_PIN + checkingDoor, RELAY_UNLOCKED);
      }
      actualDoorStates[checkingDoor] = desired_door_states[checkingDoor];
    }
    else {
#ifdef DEBUG
      Serial.println(F(""No useable state found in eeprom""));
#endif
      digitalWrite(RELAY1_PIN + checkingDoor, RELAY_UNLOCKED); // If no value was stored in the eeprom, start unlocked, for safety.
    }
  }


  if( EEPROM.read(EEPROM_STORAGE_START + 255) == 1 ){ // This position indicates whether any passwords and phone numbers have been stored in eeprom.
    Serial.println(F(""Loading phone numbers and passwords from internal memory""));
    loadEverythingFromEeprom();
  }
  else{
    Serial.println(F(""No preferences stored in internal memory yet""));
  }
}



#ifdef ALLOW_CONNECTING_TO_NETWORK
void presentation()
{
  sendSketchInfo(F(""Smart lock""), F(""2.0"")); wait(RADIO_DELAY);

  present(DEVICE_STATUS_ID, S_INFO, F(""Status"")); wait(RADIO_DELAY);
  present(SMS_CHILD_ID, S_INFO, F(""Received SMS"")); wait(RADIO_DELAY);
  present(SENDSMS_CHILD_ID, S_INFO, F(""Send SMS"")); wait(RADIO_DELAY);
  present(PHONENUMBER1_ID, S_INFO, F(""Phone number 1"")); wait(RADIO_DELAY);
  present(PHONENUMBER2_ID, S_INFO, F(""Phone number 2"")); wait(RADIO_DELAY);

  // Presenting the password fields. This is currently over coplicated, but was an experiment in making the code more flexible so it could handle a lot of locks.
  
  for( byte i = 0; i < DOOR_COUNT; i++ ){           // We loop over all the doorlocks in the system, and check if they are in the right position.
    memset(work_string,0,sizeof(work_string));
    strcpy_P(work_string, passwordMessage);          // This copies the password message that we stored in progmem (flash memory) into real memory.
    
    work_string[5] = i + 49;                         // This will create ""Door 1 password"", ""Door 2 password"", etc. In that string the number is the 5th character (starting form 0). Ascii character 49 = ""1"", character 50 = ""2"", etc.
    //Serial.println(work_string);
    present(ROTATING_PASSWORD1_ID + (i*26), S_INFO, work_string); wait(RADIO_DELAY);
    
    work_string[6] = '\\0'; // Shortens the string to just be ""Door 1"", ""Door 2"", etc.
    //Serial.println(work_string);
    present(RELAY1_CHILD_ID + i, S_BINARY, work_string, true); wait(RADIO_DELAY);
  }

  present(TRANSMISSION_STATE_CHILD_ID, S_BINARY, F(""Data transmission"")); wait(RADIO_DELAY);
  present(SMS_CONTROL_ID, S_BINARY, F(""Mobile control"")); wait(RADIO_DELAY);

  send_all_values = true;                           // Whenever a new presentation is requested, we should also send the current values of the children.
}


void send_values()
{
#ifdef DEBUG
  Serial.println(F(""Sending button states""));
#endif
  send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""OK"")),1); wait(RADIO_DELAY);  
  send(text_message.setSensor(SMS_CHILD_ID).set( F(""""))); wait(RADIO_DELAY);
  send(text_message.setSensor(SENDSMS_CHILD_ID).set( F(""Change me to send SMS""))); wait(RADIO_DELAY);
  send(text_message.setSensor(PHONENUMBER1_ID).set( phone1 ),1); wait(RADIO_DELAY);
  send(text_message.setSensor(PHONENUMBER2_ID).set( phone2 ),1); wait(RADIO_DELAY);

#ifdef DEBUG
  Serial.print(F(""Sending phone1: "")); Serial.println( phone1 );
#endif

  //for( byte i = 0; i < DOOR_COUNT; i++ ){
    //send(text_message.setSensor(ROTATING_PASSWORD1_ID + i).set( F(""change_me"") )); wait(RADIO_DELAY);
  //}
  send(text_message.setSensor(ROTATING_PASSWORD1_ID).set( rotatingPassword1 )); wait(RADIO_DELAY);
  send(text_message.setSensor(ROTATING_PASSWORD2_ID).set( rotatingPassword2 )); wait(RADIO_DELAY);

  send(relay_message.setSensor(TRANSMISSION_STATE_CHILD_ID).set(transmission_state),1); wait(RADIO_DELAY);
  send(relay_message.setSensor(SMS_CONTROL_ID).set(sms_control_state),1); wait(RADIO_DELAY);

  if( transmission_state ){                           // Send the state of the locks (if data transmission is allowed)
    for( byte i = 0; i < DOOR_COUNT; i++ ){
      send(lock_message.setSensor(RELAY1_CHILD_ID + i).set( actualDoorStates[i] )); wait(RADIO_DELAY);
    }
  }
}
#endif // connecting to network

void setup()
{
  wait(1000);

#ifndef JESSE
  pinMode(BUTTON1_PIN, INPUT_PULLUP);
  pinMode(BUTTON2_PIN, INPUT_PULLUP);
#endif

#ifdef ALLOW_CONNECTING_TO_NETWORK

#ifdef JESSE
  pinMode(MOTOR_FORWARD_PIN, OUTPUT);
  pinMode(MOTOR_BACKWARD_PIN, OUTPUT);
  pinMode(TOP_MOTOR_SWITCH_PIN, INPUT_PULLUP);
  pinMode(BOTTOM_MOTOR_SWITCH_PIN, INPUT_PULLUP);
  transmission_state = digitalRead(TOP_MOTOR_SWITCH_PIN); // Sets the intial state of the motorized toggle switch.
#else
  transmission_state = loadState(TRANSMISSION_STATE_CHILD_ID);
#endif
  Serial.print(F(""Initial transmission state: "")); Serial.println(transmission_state);

  
  // Has a connection to the controller been established?
  if( isTransportReady() ){
    Serial.println(F(""Connected to gateway""));
    send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""STARTING GSM""))); wait(RADIO_DELAY); 
  }else{
    Serial.println(F(""Not connected to gateway""));
    //timeOutCount = MAXIMUMTIMEOUTS;                 // Start the system in 'no connection' mode, meaning the backup passwords may be used.
  }

#endif // allow connecting to network


#ifdef DEBUG
  for ( int i = EEPROM_STORAGE_START; i < EEPROM_STORAGE_START + 512; i++ ){
    //char k = EEPROM.read(i);
    //Serial.print(i); Serial.print(F(""="")); Serial.write(k); Serial.print(F("" ("")); Serial.println( (byte) k);
  }
#endif


  Serial.println(F(""Connecting to GSM..""));
  modem.begin(57600);  //57600                      // The modem automatically adapts to work at the same baud rate when we send a few commands.
  modem.println(F(""AT""));
  wait(300);
  modem.println(F(""AT""));
  wait(300);
  modem.println(F(""AT""));
  wait(300);
  
  modem.println(F(""AT&F""));                         // Reset the GSM modem.
  wait(15000);                                      // After a reset, the GSM modem needs some time to settle.

  while( modem.available() > 0 ){                   // Empty the buffer before we start the actual bootup procedure
    modem.read();
  }

  wdt_enable(WDTO_8S);                              // Starts the watchdog timer. If it is not reset once every few seconds, then the entire device will automatically restart.                                
}


void loop()
{
  static unsigned long last_loop_time = 0;          // Holds the last time the main loop ran.
  static bool buttonBeingPressed = 0;               // Used to debounce the push buttons.
  static byte number_of_bytes_received = 0;         // How many characters we've stored in the serial_line character array.
  static byte loop_counter = 0;                     // Count how many loops have passed (reset to 0 after at most 254 loops).
  static byte modem_counter = 0;

  //wdt_reset();                                      // Reset the watchdog timer


#ifdef ALLOW_CONNECTING_TO_NETWORK
  // If a presentation is requested, we also send the values of the children.
  if( send_all_values ){
#ifdef DEBUG
    Serial.println(F(""RESENDING VALUES""));
#endif
    send_all_values = 0;
    send_values();
  }

  // User initiated a transmission state change remotely
  if( desired_transmission_state != transmission_state ){
    Serial.print(F(""Desired transmission state has changed to "")); Serial.println(desired_transmission_state);
#ifdef JESSE
    transmission_state = motor_switch(desired_transmission_state);
#else
    transmission_state = desired_transmission_state;
#endif
    EEPROM.update(EEPROM_STORAGE_START + TRANSMISSION_STATE_CHILD_ID,transmission_state); // Remember the prefered state in the eeprom memory. This will make sure it is remembered after a reboot.

    Serial.print(F(""Sending new transmission state: "")); Serial.println(transmission_state);
    //controller_got_transmission_state = false;
    if( transmission_state ){
      send_values();                                // If data transmissin is re-enabled, all current values (including the real state of the locks) are sent to the controller.
    }
    else {
      send(relay_message.setSensor(TRANSMISSION_STATE_CHILD_ID).set(transmission_state),1); wait(RADIO_DELAY); // We acknowledge to the controller that we are now in the new state.
    }
    
  }

  // User initiated a SMS control change remotely
  if( desired_sms_control_state != sms_control_state ){
    Serial.print(F(""Desired sms control state has changed to "")); Serial.println(desired_sms_control_state);
    sms_control_state = desired_sms_control_state;
    
    Serial.print(F(""Sending new sms control state: "")); Serial.println(sms_control_state);
    //controller_got_transmission_state = false;
    send(relay_message.setSensor(SMS_CONTROL_ID).set(sms_control_state),1);  wait(RADIO_DELAY);// We acknowledge to the controller that we are now in the new state.
    wait(RADIO_DELAY);
  }

  if( send_sms ){
    //Serial.print(F(""controller: send sms. Work_string: "")); Serial.println(work_string);
    send_sms = false;                               // Indicates the sms has been sent.
    sendSMS();
  }

  // If any of the passwords or phone numbers have been updated, they should be stored/updated in eeprom.
  if( store_to_eeprom ){
    store_to_eeprom = false;                        // Indicates the storage cycle is done.
    storeEverythingToEeprom();
    send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""New value stored""))); wait(RADIO_DELAY);
  }
  
#endif // connecting to network

  


  //
  //  KEEP SIM CARD ALIVE
  //
  
#ifdef SEND_SMS_EVERY_49_DAYS
  // This is an optional feature.
  // Every 49,7 days (using the millis() rollover) the system sends out an SMS. This helps keep the simcard active and registered on the GSM network. 
  // Use at your own risk: if the system experiences a power loss, the timer starts at 0 again. If your experience frequent powerlosses, then the simcard might be-deregistered anyway, since the keep-alive SMS's won't get sent. 
  // A slight delay is built in: the first sms is sent a week after the smart lock becomes active. This avoid sending a lot of SMS's if you are still playing with setting up the device, and powerlosses may be frequent.
  // This smart lock also offers another option. You can let the controller trigger the sending of the sms using the 'send test sms' button. Of course, your controller could also be down when you scheduled to trigger the button.
  static bool keepAliveSMSsent = false;             // Used to make sure an SMS is only sent as the milliseconds starts, and not during every loop in the millisecond.
  if(millis() < 5){
    keepAliveSMSsent  = false;                      // When the clock rolls over, set the variable back so that a new SMS can be sent.
  }
  if (millis() > 604800000 && millis() < 604800010 && keepAliveSMSsent == false){ // 604800000 = 1 week in milliseconds. Sending the first keep-alive SMS after a week avoids sending a lot of SMS-es while testing the system (which may involve a lot of reboots).
    keepAliveSMSsent  = true;
    strcpy(work_string, phone1); 
    sendSMS();                                      // If the work string only contains a phone number - as is the case here - a generic ""Hello from Candle"" SMS will be sent.
  }
#endif



  //
  //  GSM BOOTUP SEQUENCE
  //

  if( modem_state == MODEM_BUFFER_EMPTY && modem_booted == false ){
    // The receive buffer has been processed. Time to send a new command in the list, or just go into ""ready"" state.
    modem_counter++;
    modem_state = WAITING_FOR_RESPONSE_FROM_MODEM;
    Serial.println();
    Serial.print(F(""__GSM boot step "")); Serial.println(modem_counter);
#ifdef ALLOW_CONNECTING_TO_NETWORK
    send(text_message.setSensor(DEVICE_STATUS_ID).set( (char) modem_counter )); wait(RADIO_DELAY);
#endif
    
    switch( modem_counter ){

      case 0:
        modem.println(F(""AT""));                     // Never called, since the modem_counter jumps from 0 to 1 just before this.
        break;
      case 1:
        modem.println(F(""AT+CCID""));                // Initiating the GSM modem
        //Serial.println(F(""<<AT""));
        break;
      case 2:
        modem.println(F(""ATE0""));                   // Don't echo the AT commands back to the Arduino. ATE1 turns it on instead (and it's the default too).
        //Serial.println(F(""<<ATE0""));
        break;
      case 3:
        modem.println(F(""AT+EGMR=?""));              // Gets IMEI code.
        break;
      case 4:
        modem.println(F(""AT+EGMR=2,7""));            // Set IMEI write state
        wait(3000);
        break;
      case 5:
        modem.print(F(""AT+CSTT=\\""""));               // Send the GPRS settings
        modem.print(APN_URL);
        modem.print(F(""\\"",\\""""));
        modem.print(APN_USERNAME);
        modem.print(F(""\\"",\\""""));
        modem.print(APN_PASSWORD);
        modem.println(F(""\\""""));
        wait(3000);
        break;
      case 6:
        modem.println(F(""AT+COPS=0""));              // Connect to the GSM network
        wait(3000);
        break;
      case 7:
        modem.println(F(""AT+CGATT=1""));             // Enable GPRS connection
        wait(4000);
      case 8:
        modem.println(F(""AT+CGATT?""));              // Did we manager to connect to GPRS?
        break;
      case 9:
        modem.println(F(""AT+CREG?""));               // Is the modem succesfully registered on the network?
        break;
      case 10:
        modem.println(F(""AT+CMGF=1""));              // SMS mode. Get SMS as plain text. 
        break;
      case 11:
        modem.println(F(""AT+CSDH=0""));              // CSDH=0 asks the modem to not send full SMS headers.
        break;
      case 12:
        //Serial.println(F(""10_delete all sms""));
        modem.println(F(""AT+CNMI=2,2,0,0,0""));      // Listen to incoming messages.
        break;
      case 13:
        //Serial.println(F(""8_sms_live_mode""));            
        modem.println(F(""AT+CMGD=1,4""));            // Delete all SMS messages stored on the modem.
        wait(4000);
        break;
      case 14:
        modem.println(F(""AT+COPS?""));               // Outputs which GSM network the modem is connected to
        break;
      /*
      case 12:
        //modem.println(F(""AT+CGATT?""));
        break;
      case 13:
        //modem.println(F(""AT+CSCS=?""));
        break;
      case 14:
        //modem.println(F(""AT+COPS?""));
        break;
      case 15:
        //modem.println(F(""AT^STF=1""));
        //modem.println(F(""AT+CSCS=\\""GSM\\""""));
        //modem.println(F(""AT+CSCS=\\""8859-1\\""""));
        //modem.println(F(""AT+CSCS=\\""UCS2\\""""));
        //modem.println(F(""AT^STF=1""));
        //modem.println(F(""AT^STA=?""));
        //modem.println(F(""AT+CSSN=?""));
        break;
      */
      
      default:
        Serial.println();
        Serial.println(F(""MODEM BOOT COMPLETE""));
        Serial.println();
        modem_state = MODEM_BUFFER_EMPTY;
        modem_booted = true;
#ifdef ALLOW_CONNECTING_TO_NETWORK
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""GSM READY""))); wait(RADIO_DELAY);
#endif
        break;
    }
    wdt_reset();
    wait(2000);
  }
  


  //
  //  MAIN LOOP
  //

  if( millis() - last_loop_time > LOOP_DURATION ){ // Runs every second
    last_loop_time = millis();

    wdt_reset();                                  // Reset the watchdog timer. If this doesn't happen, the device must have crashed, and it will be automatically rebooted by the watchdog.

    if( loop_counter >= SECONDS_BETWEEN_HEARTBEAT_TRANSMISSION ){ // If a couple of minutes have passed, tell the controller we're still here
      loop_counter = 0;
      Serial.println(F(""Sending heartbeat""));
      sendHeartbeat();                        
      if( modem_booted == false && modem.available() == 0 && modem_state == WAITING_FOR_RESPONSE_FROM_MODEM ){ // If the boot process never (fully) ran, then this allows for a retry.
        modem_counter = 0;
        modem_state = MODEM_BUFFER_EMPTY;
#ifdef ALLOW_CONNECTING_TO_NETWORK
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""Modem not responding"") )); wait(RADIO_DELAY);
#endif   
#ifdef DEBUG
        Serial.println(F(""Resetting modem state""));
#endif
      }
    }
    else{
      loop_counter++;
    }
  }



  //
  //  Manage power to the locks
  //

  for( byte checkingDoor = 0; checkingDoor < DOOR_COUNT; checkingDoor++ ){ // We loop over all the doorlocks in the system, and check if they are in the right position.
    //Serial.print(F(""checkingDoor "")); Serial.println(checkingDoor);
    if( desired_door_states[checkingDoor] != actualDoorStates[checkingDoor] ){
      Serial.println(F(""Changing door status""));
      char updateMessage[11];
      if( desired_door_states[checkingDoor] == LOCKED ){
        digitalWrite(RELAY1_PIN + checkingDoor, RELAY_LOCKED);
        strcpy_P(updateMessage, lockedMessage);   // Copy the string ""  locked"" from PROGMEM / FLASH into RAM
      }
      else if( desired_door_states[checkingDoor] == UNLOCKED ){
        digitalWrite(RELAY1_PIN + checkingDoor, RELAY_UNLOCKED);
        strcpy_P(updateMessage, unlockedMessage); // Copy the string ""  unlocked"" from PROGMEM / FLASH into RAM
      }
      updateMessage[0] = checkingDoor + 49;       // Here the first character of the string is changed to create a useful message, such as ""1 locked"" or ""2 unlocked"". Ascii character '1' has number 49. 2 has number 50, etc.
#ifdef DEBUG
      Serial.print(F(""updateMessage: ""));Serial.println(updateMessage);
      Serial.print(F(""relay ID: "")); Serial.println(RELAY1_CHILD_ID + checkingDoor);
      Serial.print(F(""new desired state: "")); Serial.println(desired_door_states[checkingDoor]);
#endif
#ifdef ALLOW_CONNECTING_TO_NETWORK
      if( transmission_state ){
        send(lock_message.setSensor(RELAY1_CHILD_ID + checkingDoor).set( desired_door_states[checkingDoor] )); wait(RADIO_DELAY); // Tell the controller in what state the lock is.
        send(text_message.setSensor(DEVICE_STATUS_ID).set( updateMessage )); wait(RADIO_DELAY);
      }
#endif
      actualDoorStates[checkingDoor] = desired_door_states[checkingDoor];
      EEPROM.update(EEPROM_STORAGE_START + RELAY1_CHILD_ID + checkingDoor, desired_door_states[checkingDoor]); // Store the new position in eeprom. After a reboot it will automatically jump back to this state.
    }
  }


#ifdef DOOR1_SELF_LOCKING
  if( actualDoorStates[0] == UNLOCKED ){
    Serial.println(F(""Self locking in a few seconds""));
    wdt_disable();
    wait(SELF_LOCKING_DELAY * 1000);
    wdt_enable(WDTO_8S);
    desired_door_states[0] = LOCKED;
  }
#endif


#ifdef DOOR2_SELF_LOCKING
  if( actualDoorStates[1] == UNLOCKED ){
    Serial.println(F(""Self locking in a few seconds""));
    wdt_disable();
    wait(SELF_LOCKING_DELAY * 1000);
    wdt_enable(WDTO_8S);
    desired_door_states[1] = LOCKED;
  }
#endif


#ifdef HAS_BUTTONS
  // Check button to toggle the state
  if (digitalRead(BUTTON1_PIN) == HIGH){
    //Serial.println(F(""1""));
    wait(100);
    if(buttonBeingPressed == 0){
      desired_door_states[0] = !desired_door_states[0]; // On press of the button, toggle the door 1 desired status. e.g. locked -> unlocked.
#ifdef ALLOW_CONNECTING_TO_NETWORK
      if( transmission_state ){
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""Button 1 pressed"") )); wait(RADIO_DELAY);
      }
#endif
      Serial.print(F(""Button1->"")); Serial.println(desired_door_states[0]);
    }
    buttonBeingPressed = 1;
  }
  else if (digitalRead(BUTTON2_PIN) == HIGH){
    //Serial.println(F(""2""));
    wait(100);
    if(buttonBeingPressed == 0){
      desired_door_states[1] = !desired_door_states[1]; // On press of the button, toggle the door 2 desired status. e.g. locked -> unlocked.
#ifdef ALLOW_CONNECTING_TO_NETWORK
      if( transmission_state ){
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""Button 2 pressed"") )); wait(RADIO_DELAY);
      }
#endif
      Serial.print(F(""Button2->"")); Serial.println(desired_door_states[1]);
    }
    buttonBeingPressed = 1;  
  }
  else{
    buttonBeingPressed = 0; 
  }
#endif



  //
  // CHECK FOR INCOMING DATA FROM MODEM
  //
  
  if( modem.available() > 0 ){
    
    char singleChar = modem.read();
#ifdef DEBUG
    //Serial.print(number_of_bytes_received); Serial.print(F(""="")); Serial.write(singleChar); Serial.print(F("" ("")); Serial.print( (byte) singleChar);
    //Serial.print(F(""), to go = "")); Serial.println( modem.available() );
#endif
    if( singleChar != 0 ){ // Ignore Null character. This gets sent by the modem once in a while.
      serial_line[number_of_bytes_received] = singleChar;
      number_of_bytes_received++;

      if( modem_state == WAITING_FOR_RESPONSE_FROM_MODEM ){ // We got a proper response from the modem.
        Serial.print(F("">>Got response from modem >"")); Serial.println( modem.available() );
        modem_state = MODEM_PROCESSING_RESPONSE;
      }
    }
    
    char peek_char = 49; //  ascii 1. Doesn't matter what it is really.
    if( modem.available() > 0 ){
      peek_char = modem.peek();
      //Serial.print(F(""-peek = "")); Serial.println(peek_char);
      if( peek_char == 10 ){
        //Serial.println(F(""removing peek""));
        modem.read();             // Clear the CR and LF from the buffer.
      }
    }
    
    
    if( (singleChar == 13 && peek_char == 10) || number_of_bytes_received == SERIAL_LINE_LENGTH ){ // Each line of text the modem sends ends with two special characters, the line feed (LF) and Carriage return (CR). We don't need those anymore.
      //Serial.print(F(""Received a line with a length of "")); Serial.println(number_of_bytes_received);
      serial_line[number_of_bytes_received] = '\\0';
      number_of_bytes_received = 0;
      //Serial.println(serial_line);
      //Serial.print(F(""  -to go: "")); Serial.println( modem.available() ); // After this line, how many more characters are there left in the buffer.
      processLine();
    }


    if( modem.available() == 0 ){
      if( modem_state == MODEM_PROCESSING_RESPONSE && number_of_bytes_received == 0 ){
        //Serial.println(F(""Response buffer processed""));
        modem_state = MODEM_BUFFER_EMPTY;
      }
#ifdef DEBUG
      if( number_of_bytes_received != 0 ){
        Serial.println(F(""Yikes, buffer is empty but serial_line is not complete. Buffer overflow happened?""));
        number_of_bytes_received = 0;
      }
#endif
    }
  }



} // End of main loop







// PROCESS LINE
//
// This parses the serial data from the GSM modem, and for example filters out the actual SMS text.
void processLine() 
{
#ifdef DEBUG
  Serial.print(F(""processing: "")); Serial.println(serial_line);
  //send(text_message.setSensor(SMS_CHILD_ID).set(serial_line)); wait(RADIO_DELAY);
#endif

  // If the incomingSMS has been set, that means we already found the phonenumber part of the sms, and are now at the actual sms content part.
  if ( incomingSMS == 1 ){
    incomingSMS = 0;                              // Reset for when the next sms needs to be dissected.
#ifdef DEBUG
    Serial.println(F(""-At the actual text""));
#endif
    // Does the SMS content begin with a correct password?
    byte password1length = strlen(rotatingPassword1);
    byte password2length = strlen(rotatingPassword2);
    bool password1found = strncmp(serial_line, rotatingPassword1, password1length);
    bool password2found = strncmp(serial_line, rotatingPassword2, password2length);
    password1found = !password1found;
    password2found = !password2found;

#ifdef DEBUG
    Serial.print(F(""pass 1 found?: ""));Serial.println(password1found);
    Serial.print(F(""pass 2 found?: ""));Serial.println(password2found);
#endif
    
    if( password1found || password2found ){ // If password matches, and using SMS to control the lock is allowed
      Serial.println(F(""Correct password received""));

      if( sms_control_state ){
        char * command;
        command = strstr(serial_line, "" "");          // Search for the index of the space
        if (command != NULL)                        // If successful then command now points to the second word in the SMS
        {
          // Serial.print(F(""Command = "")); Serial.println(command);
          // Check what the command is, and act on it.
          bool commandLock = strncmp (command, "" lock"", 5);
          bool commandUnlock = strncmp (command, "" unlock"", 7);
          bool commandStatus = strncmp (command, "" status"", 7);
          if(commandLock == 0){
            Serial.println(F(""->lock""));
            if(password1found){ desired_door_states[0] = LOCKED; }
            if(password2found){ desired_door_states[1] = LOCKED; }
          }
          else if(commandUnlock == 0){
            Serial.println(F(""->unlock""));
            if(password1found){ desired_door_states[0] = UNLOCKED; }
            if(password2found){ desired_door_states[1] = UNLOCKED; }
          }
          else if(commandStatus == 0){
            Serial.println(F(""command: send status sms""));
            //char updateMessage[11];
            if( password1found ){ // If it's zero, it means it was found.
              if( actualDoorStates[0] == LOCKED ){ strcpy_P(work_string, lockedMessage); }
              else { strcpy_P(work_string, unlockedMessage); }
              work_string[0] = 49; // ascii 1
            }
            if( password2found ){ 
              if( actualDoorStates[1] == LOCKED ){ strcpy_P(work_string, lockedMessage); }
              else { strcpy_P(work_string, unlockedMessage); }
              work_string[0] = 50; // ascii 2
            }
            Serial.println(F(""Status SMS: "")); Serial.println(work_string);
            sendSMS(); // Sends the work_string array, which now contains a message about the door's lock status
          }
        }
      }
    }
    else {                                        // If the SMS did not contain a good password, we will send it to the controller.
      Serial.println(F(""Incorrect password""));
      //char tempLine[25];
      //byte i = 25;                              // How many characters we will copy into the new variable
      //while ( i-- ) *( tempLine + i ) = *( serial_line + i ); // Copying characters from serial_line variable into a new one.
      //send(text_message.setSensor(SMS_CHILD_ID).set(tempLine)); wait(RADIO_DELAY);
#ifdef ALLOW_CONNECTING_TO_NETWORK
      if( transmission_state ){
        serial_line[24] = '\\0';
        send(text_message.setSensor(SMS_CHILD_ID).set(serial_line)); wait(RADIO_DELAY);
      }
#endif
    }
    Serial.println(F(""Deleting SMS message""));
    modem.println(F(""AT+CMGD=1,4""));        // Delete all received SMS messages (for A6 based GSM modem).
  }
  else {
    
    //bool connectedToNetwork = strncmp(serial_line, ""+CREG: 5"", 8);
    //if (connectedToNetwork == 0){
    if( !strncmp(serial_line, ""+CREG: 5"", 8) ){    // Connected to the GSM network
      Serial.println(F(""GSM CONNECTED""));
#ifdef ALLOW_CONNECTING_TO_NETWORK
      send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""GSM OK""))); wait(RADIO_DELAY);
#endif
    }

    else if( !strncmp(serial_line, ""+CMS ERR"", 8) ){    // Counter intuitively, if the string matches, the result is 0. In this case, the modem tells us there is an error. After an attempt to send an SMS, this could indicate a lack of network connection or lack of funds.
      Serial.println(F(""GSM ERROR (no network or funds?)""));
#ifdef ALLOW_CONNECTING_TO_NETWORK
        if( transmission_state ){
        serial_line[24] = '\\0';
        Serial.println(serial_line);
        send(text_message.setSensor(SMS_CHILD_ID).set(serial_line)); wait(RADIO_DELAY);
        wait(1000);
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""GSM network error (CMS)"") )); wait(RADIO_DELAY);
        wait(2000);
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""Check funds or phone #1"") )); wait(RADIO_DELAY);
      }
#endif
    }

    else if( !strncmp(serial_line, ""+CME ERR"", 8) ){    // This error could occus if a user sends an incorrect code to their mobile provider
      Serial.println(F(""GSM ERROR (incorrect code sent?)""));
#ifdef ALLOW_CONNECTING_TO_NETWORK
      if( transmission_state ){
        serial_line[24] = '\\0';
        send(text_message.setSensor(SMS_CHILD_ID).set(serial_line)); wait(RADIO_DELAY);
        //send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""GSM error (CME)"") )); wait(RADIO_DELAY);
        //wait(1000);
      }
#endif
    }

    // We can send special commands to the modem. The response is encoded in a 7 bit instead of 8 bit way, and needs to be decoded.
    else if( !strncmp(serial_line, ""+CUSD:"", 6) ){ // We received the response from the *# command.

      Serial.println(F(""Decoding"")); // Serial.println(serial_line);
      
      byte commandPos = 11;                       // 11 is the position in the character array where the returned command actually starts.
      byte savePos = 0;                           // The position in the array where we are storing the new value.
      //static byte shift = 0;                      // How many of the bits must be shifted over to the next byte. Since are are handling 8 bits but only need 7, we keep having one bit left over. Once there is a need to shift 7 bits, that means we have the extra 'bonus' character.
      byte shift = 0;                      // How many of the bits must be shifted over to the next byte. Since are are handling 8 bits but only need 7, we keep having one bit left over. Once there is a need to shift 7 bits, that means we have the extra 'bonus' character.

      //Serial.print(F(""shift = "")); Serial.println(shift);
      byte nextLeftOver = 0;                      // The leftover bits from the current translation
      byte prevLeftOver = 0;                      // The leftover bits from the previous translation.


      //char value = 49
      while ( commandPos < SERIAL_LINE_LENGTH ){ //sizeof(serial_line) ){ // was 255 // Alternatively, the reserved size of the serial_line array is simply SERIAL_LINE_LENGTH
        
        prevLeftOver = nextLeftOver;
        nextLeftOver = 0;

        boolean should_send_line = false;
        char value = serial_line[commandPos]; // Get a character from the serial data.
        if( value == 0 ){
          //Serial.println(F(""found NULL"")); // Shouldn't really happen?
          //should_send_line = true;
          break;
        }
        
        //Serial.print(commandPos); Serial.print(F(""="")); Serial.write(value); Serial.println(F("" ""));

        if( savePos == 24 || value == 34 || value == 0 ){
        //if( should_send_line ){
          work_string[savePos] = '\\0';
          savePos = 0;                                // Set the postion of the write head back to 0.
#ifdef DEBUG
          Serial.println(work_string);
#endif
#ifdef ALLOW_CONNECTING_TO_NETWORK
          if( transmission_state ){
            send(text_message.setSensor(DEVICE_STATUS_ID).set( work_string )); wait(RADIO_DELAY);
          }
#endif
          wait(2000);                                 // Allows the user to read the response more easily if it has multiple lines.
        }
        if( value == 34 ){       // We're at the end of the serial_line.
          //Serial.println(F(""found closing \\""""));
          break;
        }

        // Here we safeguard the bits we will need in the next round by copying them into a new variable.
        for( byte j = 0; j <= shift; j++ ){
          bitWrite( nextLeftOver, j, bitRead(value,(7-shift) + j) ); 
        }
        
        value = value << shift;                   // Scoot everything over. The bits that get destroyed have already been safeguarded.    
        value = value | prevLeftOver;             // overlay the previous left over bits. This will create the final character.
        //Serial.print("">""); Serial.println(value);
        bitWrite( value, 7, 0 );                  // Force it to be a 7-bit character by turning the 8th bit to 0. 
        //Serial.print("">""); Serial.print( (char) value);
        //Serial.print("">""); Serial.print( (char) value); Serial.print("">""); Serial.println(value);
        work_string[savePos] = value;              // Store the final decoded value back in the original serial_line array (to save memory).
        savePos++;
        
        shift++;
        if( shift == 7 ){
          //Serial.print( (char) nextLeftOver);   // Once every 7 loops the left-over part will itself be 7 bits long. We can just print this as the 7th character.
          work_string[savePos] = (char) nextLeftOver; //value;              // Store the final decoded value back in the original array.
          savePos++;
          nextLeftOver = 0;
          shift = 0;
        }
        commandPos++;
      }
      Serial.println();
    }

    else if( !strncmp(serial_line, ""+CMT:"", 4) ){  // Are we at the part of the SMS that holds the sender's phonenumber?
#ifdef DEBUG
      Serial.println(F(""+CMT found""));
      // Can we find a phonenumber in the serial line?
      Serial.print(F(""phone#1 to check against = "")); Serial.println(phone1);
      Serial.print(F(""phone#2 to check against = "")); Serial.println(phone2);
#endif
      
      char * p;
      char * q;
      //byte p;
      //byte q;      
      p = strstr (serial_line, phone1);            // At what position in the serial_line have we spotted the phone number? If it is 0 this means it has not been found.
      q = strstr (serial_line, phone2);
      if (p || q) {                               // If one of the phone numbers was found in the string, then one of these will be bigger than 0.
        Serial.println(F(""Phone number is allowed""));
        incomingSMS = 1;                          // We may now proces the sms content, which should be on the next serial line.
#ifdef DEBUG
        Serial.print(F(""Buffer still available: "")); Serial.println( modem.available() );
#endif
        return;

        //char foundNumber[15];
        //memcpy( foundNumber, &serial_line[8], 10 ); // Starts at position 10 in the serial_line and then copies 12 characters
      }
      else {
        Serial.println(F(""Permission denied for: "")); // Neither allowed phone number was detected. Fun fact: if the two phone number arrays to compare against are """" (empty), the above should also trigger, which means any phone number may control the device if no phone numbers are set.
        char foundNumber[14];                     // Holds the phone number that sent the SMS
        for (byte i = 8; i < 20; i++) {
          char character = serial_line[i];
          if( isDigit(character) ){
            Serial.write(character);
            foundNumber[i - 8] = character;
            foundNumber[i - 7] = '\\n';
          }
        }
        Serial.println();
        // Send the unexpected phone number:
#ifdef ALLOW_CONNECTING_TO_NETWORK
        send(text_message.setSensor(DEVICE_STATUS_ID).set(F(""Unknown phone number!""))); wait(RADIO_DELAY);
        send(text_message.setSensor(SMS_CHILD_ID).set( foundNumber )); wait(RADIO_DELAY); // Tell the controller which phone number just sent us an SMS.
#endif
      }
    }
  }
}

#ifdef ALLOW_CONNECTING_TO_NETWORK
// This function is called when messages from the home controller arrive.
void receive(const MyMessage &message)
{
  //timeOutCount = 0;
#ifdef DEBUG
  Serial.print(F(""->receiving message for child "")); Serial.println(message.sensor);
#endif

  if( message.isAck() ){
#ifdef DEBUG
    Serial.println(F(""- Echo""));
#endif
  }
  else if( message.type == V_LOCK_STATUS ){       // Change lock state  
    desired_door_states[message.sensor - RELAY1_CHILD_ID] = message.getBool()?RELAY_LOCKED:RELAY_UNLOCKED;
    Serial.print(F(""Controller -> door "")); Serial.print(message.sensor - RELAY1_CHILD_ID); Serial.print(F("" -> "")); Serial.println(desired_door_states[message.sensor - RELAY1_CHILD_ID]);

    if( !transmission_state ){ // We only echo this state back to the controller straight from the receive function if the main loop won't update the controller because the data transmission is disabled.
      send(lock_message.setSensor(message.sensor).set( message.getBool() )); // Tell the controller that the value was received.
    }
  }
  else if( message.type == V_STATUS ){

    send(relay_message.setSensor(message.sensor).set( message.getBool() ));
    
    if( message.sensor == TRANSMISSION_STATE_CHILD_ID ){  // Data transmission toggle  
      desired_transmission_state = message.getBool(); //?RELAY_ON:RELAY_OFF;
      //send(relay_message.setSensor(TRANSMISSION_STATE_CHILD_ID).set(desired_transmission_state));
      Serial.print(F(""-New desired transmission state: "")); Serial.println(desired_transmission_state);
    }
    else if( message.sensor == SMS_CONTROL_ID ){    // SMS control toggle
      desired_sms_control_state = message.getBool(); //?RELAY_ON:RELAY_OFF;
      //send(relay_message.setSensor(SMS_CONTROL_ID).set(desired_sms_control_state));
      Serial.print(F(""-New desired sms control state: "")); Serial.println(desired_sms_control_state);
    }
  }
  else if( message.type == V_TEXT ){

    Serial.print(F(""- incoming string: ""));Serial.println(message.getString());
    send(text_message.setSensor(message.sensor).set( message.getString() )); // Tell the controller that the value was received.


    // If the controller asks us to send an SMS.
    if( message.sensor == SENDSMS_CHILD_ID ){
      //strcpy(smsToSend, message.getString());
      strcpy(work_string, message.getString());
      send_sms = true;
      //send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""Sending SMS..."")));
    }

    if( message.sensor == ROTATING_PASSWORD1_ID ){
      if( rotatingPassword1 != message.getString() ){
        strcpy(rotatingPassword1, message.getString());
        Serial.print(F(""Rotating password 1 is now: "")); Serial.println(rotatingPassword1);
        store_to_eeprom = true; 
        //send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""received latest password 1""))); wait(RADIO_DELAY);
      }
    }
    else if( message.sensor == ROTATING_PASSWORD2_ID ){
      if( rotatingPassword2 != message.getString() ){
        strcpy( rotatingPassword2, message.getString());
        Serial.print(F(""Rotating password 2 is now: "")); Serial.println(rotatingPassword2);
        store_to_eeprom = true; 
        //send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""received latest password 2""))); wait(RADIO_DELAY);
      }
    }
    
    // Receiving the (parts of) phonenumbers that are allowed to operate the smart lock.
    else if( message.sensor == PHONENUMBER1_ID ){
      strcpy(phone1, message.getString());
      store_to_eeprom = true;
      Serial.println(F(""received phone #1 "")); 
#ifdef DEBUG
      Serial.print(F(""phone1: "")); Serial.println(phone1);
#endif
    }
    else if( message.sensor == PHONENUMBER2_ID ){
      //if( sizeof(message.getString()) > 2 ){
      strcpy(phone2, message.getString());
      store_to_eeprom = true; 
      //}
      Serial.println(F(""received phone #2 ""));
#ifdef DEBUG
      Serial.print(F(""phone2: "")); Serial.println(phone2);
#endif
    }

    // If could also be that the Status and Received SMS string are sent back. Those should just be ignored.
  }
}
#endif // connecting to network




// Function to send an SMS to the main phone number.
void sendSMS()
{

  boolean placeholder = strstr(work_string, ""Change me to send SMS"");
  
  if( modem_booted && modem_state == MODEM_BUFFER_EMPTY && placeholder == NULL){
#ifdef DEBUG
    Serial.print(F(""In sendSMS. string = "")); Serial.println(work_string);
    Serial.println(placeholder);
#endif

    //boolean actual_new_SMS_message = strstr(work_string, ""Change me to send SMS"");          // Search for the index
    //if (actual_new_SMS_message == NULL){                        // If successful then command now points to the second word in the SMS
  
    byte i = 0;
    char c = 49;
    
    if( work_string[0] == 42 ){       // Detect is the SMS to send starts with a *. If so, it will be parsed as command to the telephony provider. For example, with LycaMobile the code *101# will tell you your balance, and *102# will tell you your phone number.
      Serial.println(F(""starts with *""));

      boolean contains_hash_character = false;
      while( c != 35 && i < WORK_STRING_SIZE ){
        if( work_string[i] == 35 ){                    // ascii character 35 is the #
          //Serial.println(F(""#""));
          contains_hash_character = true;             // We only send the command if the string contains a closing # too.
        }
        i++;
      }
      
      if( contains_hash_character ){
        modem_state = WAITING_FOR_RESPONSE_FROM_MODEM;
#ifdef ALLOW_CONNECTING_TO_NETWORK
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""..."") )); wait(RADIO_DELAY);
#endif
        //while( modem.available() ){ // The response may be large, so in this case we clear the existing buffer.
        //  modem.read();
        //}
        modem.print(F(""AT+CUSD=1,\\""""));
        i = 0;
        c = 49;
        while( c != 35 && i < WORK_STRING_SIZE ){     // While we're not at the closing # in the command yet, we print the characters of the command
          c = work_string[i];                          // Could this step be skipped, and just print work_string[i] directly?
          //Serial.println(c);
          modem.write(c);
          i++;
        }
        modem.println(F(""\\"",15""));              // Send a request for data to your provider, such as your prepaid balance or your phone number.
        modem_state = WAITING_FOR_RESPONSE_FROM_MODEM;
      }
    }
    
    else if( (work_string[0] == 43 || work_string[0] == 48) && isDigit(work_string[1]) && isDigit(work_string[2]) ){ //&& work_string[1] > 47 && work_string[1] < 58){ // The numbers 43 and 48 are the ascii codes for + and 0 respectively
      Serial.println(F(""String started with 0 or +"")); // We can only send an SMS is the SMS starts with a phone number.
      modem_state = WAITING_FOR_RESPONSE_FROM_MODEM;
      modem.print(F(""AT+CMGS=\\""""));
      i = 0;
      c = 49;
      boolean at_actual_content = false;
      while( c != 0 && i < WORK_STRING_SIZE ){
        c = work_string[i];
        /*
        if( at_actual_content == false && c > 57){    // If we detect an alphabetical letter, perhaps the user has forgotten to use a space after the phone number. Here we add it manually.
          Serial.println(F(""User forgot space?""));
          c = "" "";
          i--;
        }
        */
        if( c == 32 && at_actual_content == false ){ // 32 is the ascii code for a space
          at_actual_content = true;
          modem.print(F(""\\""\\r""));
          Serial.print(F(""]Space[""));
          wait(500);
        }
        
        modem.write(c);
        Serial.write(c);
        i++;
      }
      if( at_actual_content == false ){ // The string never contained a space / sms text, so we use a default one.
        modem.print(F(""\\""\\r""));
        wait(500);
        modem.print(F(""Smart lock says hello""));
      }
      //modem.write(0x1A); // The command to actually send away the SMS.
      modem.println( char(26) );
      modem_state = WAITING_FOR_RESPONSE_FROM_MODEM;
      Serial.println(F(""]SMS sent""));
#ifdef ALLOW_CONNECTING_TO_NETWORK
      send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""SMS passed to modem"") )); wait(RADIO_DELAY);
#endif
    }
    
    else if( phone1[0] == 43 || phone1[0] == 48 ){ // The numbers 43 and 48 are the ascii codes for + and 0 respectively
      Serial.println(F(""Using phone #1""));

      modem.print(F(""AT+CMGS=\\"""")); modem.print(phone1); modem.println(F(""\\""\\r""));
      wait(200);
      //modem.print(""test message from A6"");

      i = 0;
      c = 49;
      while( c != 0 && i < WORK_STRING_SIZE ){
        c = work_string[i];
        modem.write(c);
        Serial.write(c);
        i++;
      }
      
      modem.println (char(26)); // ctrl-z
      /*
      modem.print(F(""AT+CMGS=\\""""));
      i = 0;
      c = 49;
      boolean at_actual_content = false;
      while( c != 0 && i < sizeof(phone1) ){
        c = phone1[i];
        modem.write(c);
        Serial.write(c);
        i++;
      }
      modem.println(F(""\\""\\r""));
      Serial.print(F(""]Space[""));
      */
      /*
      wait(200);
      i = 0;
      c = 49;
      while( c != 0 && i < WORK_STRING_SIZE ){
        c = work_string[i];
        modem.write(c);
        Serial.write(c);
        i++;
      }
      modem.write(0x1A); // The command to actually send away the SMS.
      */
      Serial.println(F(""]SMS sent to phone1""));
      modem_state = WAITING_FOR_RESPONSE_FROM_MODEM;
#ifdef ALLOW_CONNECTING_TO_NETWORK
      send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""SMS sent to phone 1""))); wait(RADIO_DELAY);
#endif
    }
    else{
      Serial.println(F(""No good phone number set, so cannot send SMS""));
#ifdef ALLOW_CONNECTING_TO_NETWORK
      if( transmission_state ){
        send(text_message.setSensor(DEVICE_STATUS_ID).set( F(""No phone number 1""))); wait(RADIO_DELAY);
      }
#endif
    }

#ifdef ALLOW_CONNECTING_TO_NETWORK
      send(text_message.setSensor(SENDSMS_CHILD_ID).set( F(""Change me to send SMS""))); //wait(RADIO_DELAY);
#endif

  wait(1000);
    
    
  }
#ifdef DEBUG
  else{
    Serial.println(F(""Will/can not send this SMS""));
  }
#endif
}









#ifdef JESSE
boolean motor_switch(boolean destination) {
  Serial.print(F(""Motor switching to "")); Serial.println(destination);
  //Serial.println(F(""This list of measurements should start with 1 and end with 0""));

  digitalWrite(MOTOR_FORWARD_PIN, !destination);
  digitalWrite(MOTOR_BACKWARD_PIN, destination);

  boolean error = false;
  byte counter = 0;
  if(destination == false){                       // Moving to on state, in which the bototm switch is 1 and the top switch is 0.
    while( digitalRead(BOTTOM_MOTOR_SWITCH_PIN) ){ // While the bottom switch reads 1 it is not being pressed. When it is pressed, it will go to 0, and exit this loop.
      wait(3);
      Serial.println(digitalRead(BOTTOM_MOTOR_SWITCH_PIN));
      counter++;
      if(counter > 100){                          // This is a safety feature to exit the loop if something strange is going on.
        Serial.print(F(""break""));
        error = true;
        break;
      }
    }
  }
  else{
    while( digitalRead(TOP_MOTOR_SWITCH_PIN) ){
      wait(3);
      Serial.println(digitalRead(TOP_MOTOR_SWITCH_PIN));
      counter++;
      if(counter > 100){
        error = true;
        Serial.print(F(""break""));
        break;
      }
    }
  }
  digitalWrite(MOTOR_FORWARD_PIN, LOW);
  digitalWrite(MOTOR_BACKWARD_PIN, LOW);
  
  if( error == false ){
    //EEPROM.update(EEPROM_STORAGE_START + TRANSMISSION_STATE_CHILD_ID, transmission_state);   // We remember the current state of the toggle switch.
    Serial.println(F(""WENT OK""));
    return destination;
    Serial.print(F(""-Motor switched. New transmission state: "")); Serial.println(transmission_state);
  }
  else{
    Serial.println(F(""ERROR motor swiching to the new position got stuck in an endless loop""));
    wait(400); // Give the motor some time to cool down ever so slightly
    Serial.println(F(""ERROR motor swiching to the new position got stuck in an endless loop cooler done""));
    return !digitalRead(TOP_MOTOR_SWITCH_PIN);    // If the top switch (which is the main one that determines the transmission state) is in the on state, the top switch will read as 0, so we invert it.
  }
}
#endif // Jesse




void storeToEeprom(char TheArray[], int n, int eeprom_starting_position)       // Currently not used, but could be used to improve the code
{
  //Serial.println(F(""storing to eeprom: ""));
  char c = 49; // ""1"", a random non-null character
  for ( int i = 0; i < n; i++ ){
    if( c != '\\0'){           // After we find the zero that terminiates the string, we keep writing zeros to the rest of the eeprom storage location.
      c = TheArray[i];
    }
    //Serial.print(i); Serial.print(F(""="")); Serial.println(c);
    EEPROM.update(eeprom_starting_position + i, c);
  }
}
      
      
void loadFromEeprom(char TheArray[], int n, int eeprom_starting_position)
{
  //Serial.println(F(""loading from eeprom: ""));
  for ( int i = 0; i < n; i++ ){
    TheArray[i] = EEPROM.read(eeprom_starting_position + i);
    //Serial.print(i); Serial.print(F(""="")); Serial.println(TheArray[i]);
  }
}

void storeEverythingToEeprom(){
#ifdef DEBUG
  Serial.println(F(""{{ Storing everything to eeprom""));
#endif
  EEPROM.update(EEPROM_STORAGE_START + 255,1);           // Indicates that the eeprom now contains user data.
  storeToEeprom(rotatingPassword1, 26, EEPROM_STORAGE_START + ROTATING_PASSWORD1_ID);
  storeToEeprom(rotatingPassword2, 26, EEPROM_STORAGE_START + ROTATING_PASSWORD2_ID);
  storeToEeprom(phone1, 15, EEPROM_STORAGE_START + PHONENUMBER1_ID); // To be more future proof, we store the phone numbers a little higher than the passwords so that we could store 4 passwords (at positions 10, 36, 52 87), and then 4 phone numbers (120, 135, 150, 165)
  storeToEeprom(phone2, 15, EEPROM_STORAGE_START + PHONENUMBER2_ID);  
}


void loadEverythingFromEeprom(){
#ifdef DEBUG
  Serial.println(F(""}} Loading everything from eeprom""));
#endif
  loadFromEeprom(rotatingPassword1, 26, EEPROM_STORAGE_START + ROTATING_PASSWORD1_ID);
  loadFromEeprom(rotatingPassword2, 26, EEPROM_STORAGE_START + ROTATING_PASSWORD2_ID);
  loadFromEeprom(phone1, 15, EEPROM_STORAGE_START + PHONENUMBER1_ID);
  loadFromEeprom(phone2, 15, EEPROM_STORAGE_START + PHONENUMBER2_ID);
}












/*
 * 
 * The MySensors Arduino library handles the wireless radio link and protocol
 * between your home built sensors/actuators and HA controller of choice.
 * The sensors forms a self healing radio network with optional repeaters. Each
 * repeater and gateway builds a routing tables in EEPROM which keeps track of the
 * network topology allowing messages to be routed to nodes.
 *
 * Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
 * Copyright (C) 2013-2015 Sensnology AB
 * Full contributor list: https://github.com/mysensors/Arduino/graphs/contributors
 *
 * Documentation: http://www.mysensors.org
 * Support Forum: http://forum.mysensors.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 * 
 */
",16166,True,2800.723149824565,median
"/**
 * MetroMiniABS.ino -- An OpenLCB node that implements a single Automatic Block
 * Signal.  This node presumes the hardware detailed at 
 * https://github.com/RobertPHeller/RPi-RRCircuits/tree/master/MetroMiniABS
 * This board uses an Adafruit Metro Mini, which is a Arduino Uno R3 clone on 
 * a mini form factor: 1.7""x.7"", with 28 pins as two rows of 14 .6"" with a .1"" 
 * pitch (same footprint as a wide DIL-28).
 *
 * I/O pin usage:
 *
 * D3 Red signal lamp (PWM)
 * D4 Blue Button/Led
 * D5 Yellow signal lamp (PWM)
 * D6 Green signal lamp (PWM)
 * D7 Gold Button/Led
 * D8 Occupancy Detector
 *
 * Events used:
 *
 * Consumed:
 *   Next Block Occupied
 *   Next Block Clear
 * Produced:
 *   Block Occupied
 *   Block Clear
 *   Stop Aspect Triggered
 *   Stop Aspect Released
 *   Approach Aspect Triggered
 *   Approach Aspect Released
 *   Clear Aspect Triggered
 *   Clear Aspect Released
 *
 * Additional configuration:
 *
 * Common Anode: Yes/No
 * BiPolar Searchlight: Yes/No
 * Stop (red) Brightness: 0-255
 * Approach (yellow) Brightness: 0-255
 * Clear (green) Brightness: 0-255
 * Yellow Hue (ratio of red to green): 0-255
 *
 */
// OlcbBasicNode
//   A prototype of a basic 4-channel OpenLCB board
// 
//   setup() determines which are consumers and
//   which are producers
//
//   Bob Jacobsen 2010, 2012
//      based on examples by Alex Shepherd and David Harris
//==============================================================

// next line for stand-alone compile
#include <Arduino.h>

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <avr/pgmspace.h>
#include ""logging.h""

// The following lines are needed because the Arduino environment 
// won't search a library directory unless the library is included 
// from the top level file (this file)
#include <EEPROM.h>
#include <can.h>
#include <ButtonLed.h>
#include ""ButtonLed_nobutton.h""
#include ""ButtonLed_nc.h""
#include ""ButtonLed_noled.h""
#include ""SignalOptions.h""
#include ""Mast.h""


#include ""OlcbCommonVersion.h""
#include ""NodeID.h""

// init for serial communications if used
#define         BAUD_RATE       57600

NodeID nodeid(0x05,0x01,0x01,0x01,0x22,0x80);    // This node's default ID; must be valid 

// Define pins
#define BLUE 4
#define GOLD 7

#define BLOCKOCC 8 // No led!
#define SIGNALGREEN 6 // No button 
#define SIGNALYELLOW 5 // No button
#define SIGNALRED 3 // No button

ButtonLed_noled blockocc(BLOCKOCC,LOW);
ButtonLed_nc nextblock(0); // No actual pin 
ButtonLed_nobutton signalgreen(SIGNALGREEN);
ButtonLed_nobutton signalyellow(SIGNALYELLOW);
ButtonLed_nobutton signalred(SIGNALRED);

struct {
    char nodename[20];
    char nodedescr[24];
    SignalOptions signalOptions;
} configOptions;

Mast mast(&blockocc,&nextblock,&signalgreen,&signalyellow,&signalred,
          &(configOptions.signalOptions));

#define NUM_EVENT 10

// next lines get ""warning: only initialized variables can be placed into program memory area"" due to GCC bug
extern ""C"" {
 const char configDefInfo[] PROGMEM = {
   60, 63, 120, 109, 108, 32, 118, 101, 114, 115, 105, 111, 110, 61, 34, 49, 46, 48, 34, 63, 62, 10, 60, 63, 120, 109, 108, 45, 115, 116, 121, 108, 101, 115, 104, 101, 101, 116, 32, 116, 121, 112, 101, 61, 39, 116, 101, 120, 116, 47, 120, 115, 108, 39, 32, 104, 114, 101, 102, 61, 39, 104, 116, 116, 112, 58, 47, 47, 111, 112, 101, 110, 108, 99, 98, 46, 111, 114, 103, 47, 116, 114, 117, 110, 107, 47, 112, 114, 111, 116, 111, 116, 121, 112, 101, 115, 47, 120, 109, 108, 47, 120, 115, 108, 116, 47, 99, 100, 105, 46, 120, 115, 108, 39, 63, 62, 10, 60, 99, 100, 105, 32, 120, 109, 108, 110, 115, 58,    // | <?xml version=""1.0""?><?xml-stylesheet type='text/xsl' href='http://openlcb.org/trunk/prototypes/xml/xslt/cdi.xsl'?><cdi xmlns:|
   120, 115, 105, 61, 39, 104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97, 45, 105, 110, 115, 116, 97, 110, 99, 101, 39, 32, 120, 115, 105, 58, 110, 111, 78, 97, 109, 101, 115, 112, 97, 99, 101, 83, 99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110, 61, 39, 104, 116, 116, 112, 58, 47, 47, 111, 112, 101, 110, 108, 99, 98, 46, 111, 114, 103, 47, 116, 114, 117, 110, 107, 47, 112, 114, 111, 116, 111, 116, 121, 112, 101, 115, 47, 120, 109, 108, 47, 115, 99, 104, 101, 109, 97, 47, 99, 100,    // | xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='http://openlcb.org/trunk/prototypes/xml/schema/cd|
   105, 46, 120, 115, 100, 39, 62, 10, 10, 32, 32, 60, 105, 100, 101, 110, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 60, 109, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 62, 68, 101, 101, 112, 119, 111, 111, 100, 115, 32, 83, 111, 102, 116, 119, 97, 114, 101, 60, 47, 109, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 62, 10, 32, 32, 32, 32, 60, 109, 111, 100, 101, 108, 62, 77, 101, 116, 114, 111, 77, 105, 110, 105, 65, 66, 83, 60, 47, 109, 111, 100, 101, 108, 62, 10, 32, 32, 32, 32, 60, 104, 97, 114, 100, 119, 97, 114, 101, 86, 101, 114,    // | i.xsd'>  <identification>    <manufacturer>Deepwoods Software</manufacturer>    <model>MetroMiniABS</model>    <hardwareVer|
   115, 105, 111, 110, 62, 49, 46, 48, 60, 47, 104, 97, 114, 100, 119, 97, 114, 101, 86, 101, 114, 115, 105, 111, 110, 62, 10, 32, 32, 32, 32, 60, 115, 111, 102, 116, 119, 97, 114, 101, 86, 101, 114, 115, 105, 111, 110, 62, 49, 46, 48, 60, 47, 115, 111, 102, 116, 119, 97, 114, 101, 86, 101, 114, 115, 105, 111, 110, 62, 10, 32, 32, 60, 47, 105, 100, 101, 110, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 62, 10, 10, 32, 32, 10, 32, 32, 60, 115, 101, 103, 109, 101, 110, 116, 32, 111, 114, 105, 103, 105, 110, 61, 39, 49, 49, 50, 39, 32, 115, 112, 97, 99, 101, 61, 39, 50, 53, 51,    // | sion>1.0</hardwareVersion>    <softwareVersion>1.0</softwareVersion>  </identification>    <segment origin='112' space='253|
   39, 62, 10, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 78, 111, 100, 101, 32, 73, 68, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 60, 100, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 62, 85, 115, 101, 114, 45, 112, 114, 111, 118, 105, 100, 101, 100, 32, 100, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 32, 111, 102, 32, 116, 104, 101, 32, 110, 111, 100, 101, 60, 47, 100, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 60, 103, 114, 111, 117, 112, 62, 10, 32, 32, 32, 32, 32, 32, 60, 115, 116, 114, 105, 110, 103, 32, 115, 105, 122, 101, 61,    // | '>    <name>Node ID</name>    <description>User-provided description of the node</description>    <group>      <string size=|
   39, 50, 48, 39, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 78, 111, 100, 101, 32, 78, 97, 109, 101, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 115, 116, 114, 105, 110, 103, 62, 10, 32, 32, 32, 32, 32, 32, 60, 115, 116, 114, 105, 110, 103, 32, 115, 105, 122, 101, 61, 39, 50, 52, 39, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 78, 111, 100, 101, 32, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 115, 116, 114, 105,    // | '20'>        <name>Node Name</name>      </string>      <string size='24'>        <name>Node Description</name>      </stri|
   110, 103, 62, 10, 32, 32, 32, 32, 60, 47, 103, 114, 111, 117, 112, 62, 10, 32, 32, 32, 32, 60, 103, 114, 111, 117, 112, 62, 10, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 83, 105, 103, 110, 97, 108, 32, 73, 109, 112, 108, 101, 109, 101, 110, 116, 97, 116, 105, 111, 110, 32, 79, 112, 116, 105, 111, 110, 115, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 105, 110, 116, 32, 115, 105, 122, 101, 61, 39, 49, 39, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 67, 111, 109, 109, 111, 110, 32, 65, 110, 111, 100, 101, 60, 47, 110,    // | ng>    </group>    <group>      <name>Signal Implementation Options</name>      <int size='1'>        <name>Common Anode</n|
   97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 109, 97, 112, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 60, 114, 101, 108, 97, 116, 105, 111, 110, 62, 60, 112, 114, 111, 112, 101, 114, 116, 121, 62, 49, 60, 47, 112, 114, 111, 112, 101, 114, 116, 121, 62, 60, 118, 97, 108, 117, 101, 62, 89, 101, 115, 60, 47, 118, 97, 108, 117, 101, 62, 60, 47, 114, 101, 108, 97, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 60, 114, 101, 108, 97, 116, 105, 111, 110, 62, 60, 112, 114, 111, 112, 101, 114, 116, 121, 62, 48, 60, 47, 112, 114, 111, 112,    // | ame>        <map>          <relation><property>1</property><value>Yes</value></relation>          <relation><property>0</prop|
   101, 114, 116, 121, 62, 60, 118, 97, 108, 117, 101, 62, 78, 111, 60, 47, 118, 97, 108, 117, 101, 62, 60, 47, 114, 101, 108, 97, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 47, 109, 97, 112, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 105, 110, 116, 62, 10, 32, 32, 32, 32, 32, 32, 60, 105, 110, 116, 32, 115, 105, 122, 101, 61, 39, 49, 39, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 66, 105, 80, 111, 108, 97, 114, 32, 83, 101, 97, 114, 99, 104, 108, 105, 103, 104, 116, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32,    // | erty><value>No</value></relation>        </map>      </int>      <int size='1'>        <name>BiPolar Searchlight</name>    |
   32, 32, 32, 32, 60, 109, 97, 112, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 60, 114, 101, 108, 97, 116, 105, 111, 110, 62, 60, 112, 114, 111, 112, 101, 114, 116, 121, 62, 49, 60, 47, 112, 114, 111, 112, 101, 114, 116, 121, 62, 60, 118, 97, 108, 117, 101, 62, 89, 101, 115, 60, 47, 118, 97, 108, 117, 101, 62, 60, 47, 114, 101, 108, 97, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 60, 114, 101, 108, 97, 116, 105, 111, 110, 62, 60, 112, 114, 111, 112, 101, 114, 116, 121, 62, 48, 60, 47, 112, 114, 111, 112, 101, 114, 116, 121, 62, 60, 118, 97, 108,    // |     <map>          <relation><property>1</property><value>Yes</value></relation>          <relation><property>0</property><val|
   117, 101, 62, 78, 111, 60, 47, 118, 97, 108, 117, 101, 62, 60, 47, 114, 101, 108, 97, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 47, 109, 97, 112, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 105, 110, 116, 62, 10, 32, 32, 32, 32, 32, 32, 60, 105, 110, 116, 32, 115, 105, 122, 101, 61, 34, 49, 34, 32, 109, 105, 110, 61, 34, 48, 34, 32, 109, 97, 120, 61, 34, 50, 53, 53, 34, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 83, 116, 111, 112, 32, 40, 114, 101, 100, 41, 32, 66, 114, 105, 103, 104, 116, 110, 101, 115, 115, 60,    // | ue>No</value></relation>        </map>      </int>      <int size=""1"" min=""0"" max=""255"">        <name>Stop (red) Brightness<|
   47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 105, 110, 116, 62, 10, 32, 32, 32, 32, 32, 32, 60, 105, 110, 116, 32, 115, 105, 122, 101, 61, 34, 49, 34, 32, 109, 105, 110, 61, 34, 48, 34, 32, 109, 97, 120, 61, 34, 50, 53, 53, 34, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 65, 112, 112, 114, 111, 97, 99, 104, 32, 40, 121, 101, 108, 108, 111, 119, 41, 32, 66, 114, 105, 103, 104, 116, 110, 101, 115, 115, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 105, 110, 116, 62, 10, 32, 32, 32, 32, 32, 32,    // | /name>      </int>      <int size=""1"" min=""0"" max=""255"">        <name>Approach (yellow) Brightness</name>      </int>      |
   60, 105, 110, 116, 32, 115, 105, 122, 101, 61, 34, 49, 34, 32, 109, 105, 110, 61, 34, 48, 34, 32, 109, 97, 120, 61, 34, 50, 53, 53, 34, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 67, 108, 101, 97, 114, 32, 40, 103, 114, 101, 101, 110, 41, 32, 66, 114, 105, 103, 104, 116, 110, 101, 115, 115, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 105, 110, 116, 62, 10, 32, 32, 32, 32, 32, 32, 60, 105, 110, 116, 32, 115, 105, 122, 101, 61, 34, 49, 34, 32, 109, 105, 110, 61, 34, 48, 34, 32, 109, 97, 120, 61, 34, 50, 53, 53,    // | <int size=""1"" min=""0"" max=""255"">        <name>Clear (green) Brightness</name>      </int>      <int size=""1"" min=""0"" max=""255|
   34, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 89, 101, 108, 108, 111, 119, 32, 72, 117, 101, 32, 40, 114, 97, 116, 105, 111, 32, 111, 102, 32, 114, 101, 100, 32, 116, 111, 32, 103, 114, 101, 101, 110, 41, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 105, 110, 116, 62, 10, 32, 32, 32, 32, 60, 47, 103, 114, 111, 117, 112, 62, 10, 32, 32, 60, 47, 115, 101, 103, 109, 101, 110, 116, 62, 10, 32, 32, 60, 115, 101, 103, 109, 101, 110, 116, 32, 111, 114, 105, 103, 105, 110, 61, 39, 49, 50, 39, 32, 115, 112, 97, 99, 101, 61, 39,    // | "">        <name>Yellow Hue (ratio of red to green)</name>      </int>    </group>  </segment>  <segment origin='12' space='|
   50, 53, 51, 39, 62, 10, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 69, 118, 101, 110, 116, 115, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 60, 100, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 62, 68, 101, 102, 105, 110, 101, 32, 101, 118, 101, 110, 116, 115, 32, 97, 115, 115, 111, 99, 105, 97, 116, 101, 100, 32, 119, 105, 116, 104, 32, 105, 110, 112, 117, 116, 32, 97, 110, 100, 32, 111, 117, 116, 112, 117, 116, 32, 112, 105, 110, 115, 60, 47, 100, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 62, 10, 32, 32, 32, 32, 60, 103, 114, 111, 117, 112, 62, 10, 32, 32, 32,    // | 253'>    <name>Events</name>    <description>Define events associated with input and output pins</description>    <group>   |
   32, 32, 32, 60, 110, 97, 109, 101, 62, 66, 108, 111, 99, 107, 32, 69, 118, 101, 110, 116, 115, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 78, 101, 120, 116, 32, 66, 108, 111, 99, 107, 32, 79, 99, 99, 117, 112, 105, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60,    // |    <name>Block Events</name>      <eventid>        <name>Next Block Occupied</name>      </eventid>      <eventid>        <|
   110, 97, 109, 101, 62, 78, 101, 120, 116, 32, 66, 108, 111, 99, 107, 32, 67, 108, 101, 97, 114, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 66, 108, 111, 99, 107, 32, 79, 99, 99, 117, 112, 105, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105,    // | name>Next Block Clear</name>      </eventid>      <eventid>        <name>Block Occupied</name>      </eventid>      <eventi|
   100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 66, 108, 111, 99, 107, 32, 67, 108, 101, 97, 114, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 60, 47, 103, 114, 111, 117, 112, 62, 10, 32, 32, 32, 32, 60, 103, 114, 111, 117, 112, 62, 10, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 83, 105, 103, 110, 97, 108, 32, 65, 115, 112, 101, 99, 116, 32, 69, 118, 101, 110, 116, 115, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101,    // | d>        <name>Block Clear</name>      </eventid>    </group>    <group>      <name>Signal Aspect Events</name>      <eve|
   110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 83, 116, 111, 112, 32, 65, 115, 112, 101, 99, 116, 32, 84, 114, 105, 103, 103, 101, 114, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 83, 116, 111, 112, 32, 65, 115, 112, 101, 99, 116, 32, 82, 101, 108, 101, 97, 115, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32,    // | ntid>        <name>Stop Aspect Triggered</name>      </eventid>      <eventid>        <name>Stop Aspect Released</name>    |
   32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 65, 112, 112, 114, 111, 97, 99, 104, 32, 65, 115, 112, 101, 99, 116, 32, 84, 114, 105, 103, 103, 101, 114, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 65, 112, 112, 114, 111,    // |   </eventid>      <eventid>        <name>Approach Aspect Triggered</name>      </eventid>      <eventid>        <name>Appro|
   97, 99, 104, 32, 65, 115, 112, 101, 99, 116, 32, 82, 101, 108, 101, 97, 115, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 67, 108, 101, 97, 114, 32, 65, 115, 112, 101, 99, 116, 32, 84, 114, 105, 103, 103, 101, 114, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 60,    // | ach Aspect Released</name>      </eventid>      <eventid>        <name>Clear Aspect Triggered</name>      </eventid>      <|
   101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 32, 32, 32, 32, 60, 110, 97, 109, 101, 62, 67, 108, 101, 97, 114, 32, 65, 115, 112, 101, 99, 116, 32, 82, 101, 108, 101, 97, 115, 101, 100, 60, 47, 110, 97, 109, 101, 62, 10, 32, 32, 32, 32, 32, 32, 60, 47, 101, 118, 101, 110, 116, 105, 100, 62, 10, 32, 32, 32, 32, 60, 47, 103, 114, 111, 117, 112, 62, 10, 32, 32, 60, 47, 115, 101, 103, 109, 101, 110, 116, 62, 10, 60, 47, 99, 100, 105, 62, 10,    // | eventid>        <name>Clear Aspect Released</name>      </eventid>    </group>  </segment></cdi>|
   0
 };

 const char SNII_const_data[] PROGMEM = ""\\001MetroMiniABS\\000Metro Mini Automatic Block Signal\\0001.0\\000"" OlcbCommonVersion ; // last zero in double-quote

}; // end extern ""C""

#define SNII_var_data 94
#define SNII_var_offset 20



#define ShortBlinkOn   0x00010001L
#define ShortBlinkOff  0xFFFEFFFEL

// The patterns are not really used.  The only LEDs are powered by PWM and the
// Other ""ButtonLeds"" are input only (no led) or not connected at all and are 
// just a state.  But the BG class wants them...
long patterns[] = {
    ShortBlinkOff,ShortBlinkOn,
    ShortBlinkOff,ShortBlinkOn,
    ShortBlinkOff,ShortBlinkOn,
    ShortBlinkOff,ShortBlinkOn,
    ShortBlinkOff,ShortBlinkOn    
};

// Non of these are actual buttons with LEDs.  One input, one state, and three 
// PWM outputs.
ButtonLed* buttons[] = {
    &nextblock,&nextblock,
    &blockocc,&blockocc,
    &signalred,&signalred,
    &signalyellow,&signalyellow,
    &signalgreen,&signalgreen
};

// These are actual buttons w/LEDs
ButtonLed blue(BLUE, LOW);
ButtonLed gold(GOLD, LOW);

#include ""OlcbArduinoCAN.h""

/* *************************************************
 * EEPROM memory layout
 *     See NodeMemory.h for background info
 *
 * Internal data, not to be reset by user:
 *     0 - 3        Memory state flag
 *     4 - 5        Cycle count
 *     6 - 11       Node ID
 *
 * User configuration data:
 *     12 - 12+10*sizeof(Event)  EventID storage
 * 
 *     112 - 132     Node name (zero-term string, 20 bytes total)
 *     132 - 156     User comment (zero-term string, 24 bytes total)
 *
 *     12+44 - 12+44+10*sizeof(Event)  Events plus description strings
 *     SignalOptions follow...
 *
 *************************************************** */

#define LAST_EEPROM 12+44+NUM_EVENT*sizeof(Event)

extern ""C"" {
    uint32_t spaceUpperAddr(uint8_t space) {  // return last valid address
      switch (space) {
          case 255: return sizeof(configDefInfo) - 1; // CDI (data starts at zero)
          case 254: return RAMEND; // RAM from Arduino definition
          case 253: return LAST_EEPROM; // Configuration
      }
      return (uint32_t)3;
    }
const uint8_t getRead(uint32_t address, int space) {
  if (space == 0xFF) {
    // Configuration definition information
    return pgm_read_byte(configDefInfo+address);
  } else if (space == 0xFE) {
    // All memory reads from RAM starting at first location in this program
    return *(((uint8_t*)&rxBuffer)+address);
  } else if (space == 0xFD) {
    // Configuration space is entire EEPROM
    return EEPROM.read(address);
  } else if (space == 0xFC) { // 
    // used by ADCDI/SNII for constant data
    return pgm_read_byte(SNII_const_data+address);
  } else if (space == 0xFB) { // 
    // used by ADCDI/SNII for variable data
    return EEPROM.read(SNII_var_data+address);
  } else {
    // unknown space
    return 0; 
  }
}

void getWrite(uint32_t address, int space, uint8_t val) {
  if (space == 0xFE) {
    // All memory
    *(((uint8_t*)&rxBuffer)+address) = val;
  } else if (space == 0xFD) {
    // Configuration space
    EEPROM.write(address, val);
  } 
  // all other spaces not written
}

uint8_t protocolIdentValue[6] = {0xD7,0x58,0x00,0,0,0};
    // PIP, Datagram, MemConfig, P/C, ident, teach/learn, 
    // ACDI, SNIP, CDI


// Events this node can produce or consume, used by PCE and loaded from EEPROM by NM
Event events[] = { // should be NUM_EVENT of these
    Event(), Event(), Event(), Event(), 
    Event(), Event(), Event(), Event(),
    Event(), Event()
};

void pceCallback(int index){
    // invoked when an event is consumed; drive pins as needed
    // from index
    //
    // sample code uses inverse of low bit of pattern to drive pin all on or all off
    // (pattern is mostly one way, blinking the other, hence inverse)
    //
    //buttons[index]->on(patterns[index]&0x1 ? 0x0L : ~0x0L );
    buttons[index]->state = !(index & 0x01);
    // Process mast...
}

} // extern ""C""

NodeMemory nm(0);  // allocate from start of EEPROM
void store() { nm.store(&nodeid, events, NUM_EVENT,(uint8_t *)&configOptions,sizeof(configOptions)); }

PCE pce(events, NUM_EVENT, &txBuffer, &nodeid, pceCallback, store, &link);

// Set up Blue/Gold configuration
BG bg(&pce, buttons, patterns, NUM_EVENT, &blue, &gold, &txBuffer);

bool states[] = {false, false, false, false}; // current input states; report when changed

int scanIndex = 0;
// On the assumption that the producers (inputs) and consumers (outputs) are consecutive, 
// these are used later to label the individual channels as producer or consumer
#define FIRST_PRODUCER_CHANNEL_INDEX    0
#define LAST_PRODUCER_CHANNEL_INDEX     4
#define FIRST_CONSUMER_CHANNEL_INDEX    5
#define LAST_CONSUMER_CHANNEL_INDEX     5

extern ""C"" {
void produceFromInputs() {
    // called from loop(), this looks at changes in input pins and 
    // and decides which events to fire
    // with pce.produce(i);
    // The first event of each pair is sent on button down,
    // and second on button up.
    // 
  
  // To reduce latency, only MAX_INPUT_SCAN inputs are scanned on each loop
  //    (Should not exceed the total number of inputs, nor about 4)
#define MAX_INPUT_SCAN 4
  //
  
  for (int i = 0; i<(MAX_INPUT_SCAN); i++, scanIndex++) { // simply a counter of how many to scan
      if (scanIndex > (LAST_PRODUCER_CHANNEL_INDEX)) scanIndex = (FIRST_PRODUCER_CHANNEL_INDEX);
      if (states[scanIndex] != buttons[scanIndex*2]->state) {
          states[scanIndex] = buttons[scanIndex*2]->state;
          if (states[scanIndex]) {
              pce.produce(scanIndex*2);
          } else {
              pce.produce(scanIndex*2+1);
          }
          if (scanIndex == 0) {
              // Process mast logic...
          }
      }
  }
}

} // extern ""C""


/**
 * Setup does initial configuration
 */
void setup()
{
  // set up serial comm; may not be space for this!
  //delay(250);Serial.begin(BAUD_RATE);logstr(""\\nOlcbBasicNode\\n"");
  
  // read OpenLCB from EEPROM
  //nm.forceInitAll(); // uncomment if need to go back to initial EEPROM state
  nm.setup(&nodeid, events, NUM_EVENT, (uint8_t*) &configOptions, (uint16_t)sizeof(configOptions), (uint16_t)LAST_EEPROM);  
    if (configOptions.signalOptions.clear_brite == 0) {
        configOptions.signalOptions.reset();
        store();
    }
  
  // set event types, now that IDs have been loaded from configuration
  // newEvent arguments are (event index, producer?, consumer?)
  for (int i=2*(FIRST_PRODUCER_CHANNEL_INDEX); i<2*(LAST_PRODUCER_CHANNEL_INDEX+1); i++) {
      pce.newEvent(i,true,false); // producer
  }
  for (int i=2*(FIRST_CONSUMER_CHANNEL_INDEX); i<2*(LAST_CONSUMER_CHANNEL_INDEX+1); i++) {
      pce.newEvent(i,false,true); // consumer
  }
  
  Olcb_setup();
}

void loop() {
    bool activity = Olcb_loop();
    if (activity) {
        // blink blue to show that the frame was received
        blue.blink(0x1);
    }
    if (OpenLcb_can_active) { // set when a frame sent
        gold.blink(0x1);
        OpenLcb_can_active = false;
    }
    // handle the status lights  
    blue.process();
    gold.process();
}
",16256,True,4384.3719709128445,median
"/*

  SelectionList.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED
//U8G2_SSD1306_72X40_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD0323_OS128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD0323_OS128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 		// Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); 	 // Not tested
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_MAX7219_64X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_32X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_8X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_LS013B7DH03_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V


// End of constructor list



void setup(void) {
  
  // DOGS102 Shield (http://shieldlist.org/controlconnection/dogs102)
  // u8g2.begin(/* menu_select_pin= */ 5, /* menu_next_pin= */ 4, /* menu_prev_pin= */ 2, /* menu_home_pin= */ 3);
  
  // DOGM128 Shield (http://shieldlist.org/schmelle2/dogm128) + DOGXL160 Shield
  // u8g2.begin(/* menu_select_pin= */ 2, /* menu_next_pin= */ 3, /* menu_prev_pin= */ 7, /* menu_home_pin= */ 8);

  // MKR Zero Test Board
  //u8g2.begin(/*Select=*/ 0, /*Right/Next=*/ 1, /*Left/Prev=*/ 2, /*Up=*/ 4, /*Down=*/ 3, /*Home/Cancel=*/ A6); 

  // Arduboy
  //u8g2.begin(/*Select=*/ A0, /*Right/Next=*/ 5, /*Left/Prev=*/ 9, /*Up=*/ 8, /*Down=*/ 10, /*Home/Cancel=*/ A1); // Arduboy DevKit
  u8g2.begin(/*Select=*/ 7, /*Right/Next=*/ A1, /*Left/Prev=*/ A2, /*Up=*/ A0, /*Down=*/ A3, /*Home/Cancel=*/ 8); // Arduboy 10 (Production)

  u8g2.setFont(u8g2_font_6x12_tr);
}

const char *string_list = 
  ""Altocumulus\\n""
  ""Altostratus\\n""
  ""Cirrocumulus\\n""
  ""Cirrostratus\\n""
  ""Cirrus\\n""
  ""Cumulonimbus\\n""
  ""Cumulus\\n""
  ""Nimbostratus\\n""
  ""Stratocumulus\\n""
  ""Stratus"";

uint8_t current_selection = 0;


void loop(void) {

  current_selection = u8g2.userInterfaceSelectionList(
    ""Cloud Types"",
    current_selection, 
    string_list);

  if ( current_selection == 0 ) {
    u8g2.userInterfaceMessage(
	""Nothing selected."", 
	"""",
	"""",
	"" ok "");
  } else {
    u8g2.userInterfaceMessage(
	""Selection:"", 
	u8x8_GetStringLineStart(current_selection-1, string_list ),
	"""",
	"" ok \\n cancel "");
  }
}


",16217,True,4889.034666395181,median
"////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You 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 mx.controls.advancedDataGridClasses
{

/* import flash.display.DisplayObject;
import flash.events.Event;
 */
import mx.controls.AdvancedDataGrid;
import mx.controls.TextInput;
import mx.controls.dataGridClasses.DataGridColumn;
import mx.core.ClassFactory;
import mx.core.IFactory;
import mx.core.mx_internal;
import mx.utils.StringUtil;

import org.apache.royale.core.UIBase;
import org.apache.royale.events.Event;

use namespace mx_internal;
//--------------------------------------
//  Styles
//--------------------------------------

//include ""../../styles/metadata/TextStyles.as"";

/**
 *  The background color of the column.
 *  The default value is <code>undefined</code>, which means it uses the value of the 
 *  <code>backgroundColor</code> style of the associated AdvancedDataGrid control.
 *  The default value for the AdvancedDataGrid control is <code>0xFFFFFF</code>.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Royale 0.9.3
 */
[Style(name=""backgroundColor"", type=""uint"", format=""Color"", inherit=""no"")]

/**
 *  The name of a CSS style declaration for controlling other aspects of
 *  the appearance of the column headers.
 *  The default value is <code>undefined</code>, which means it uses the value of the 
 *  <code>headerStyleName</code> style of the associated AdvancedDataGrid control.
 *  The default value for the AdvancedDataGrid control is 
 *  <code>"".advancedDataGridStyles""</code>.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Royale 0.9.3
 */
[Style(name=""headerStyleName"", type=""String"", inherit=""no"")]

/**
 *  The number of pixels between the container's left border and its content 
 *  area.
 *  There is no default value for this style.
 *  An item renderer's setting of the <code>paddingLeft</code> property 
 *  is used to determine the default.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Royale 0.9.3
 */
//[Style(name=""paddingLeft"", type=""Number"", format=""Length"", inherit=""no"")]

/**
 *  The number of pixels between the container's right border and its content 
 *  area.
 *  There is no default value for this style.
 *  An item renderer's setting of the <code>paddingRight</code> property 
 *  is used to determine the default.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Royale 0.9.3
 */
//[Style(name=""paddingRight"", type=""Number"", format=""Length"", inherit=""no"")]

/**
 *  The AdvancedDataGridColumn class describes a column in an AdvancedDataGrid control.
 *  There is one AdvancedDataGridColumn per displayable column, even if a column
 *  is hidden or off-screen.
 *  The data provider items of an AdvancedDataGrid control 
 *  can contain properties that are not displayed,
 *  and therefore, do not need an AdvancedDataGridColumn.
 *  An AdvancedDataGridColumn allows specification of the color and font of the text
 *  in a column; specification of what kind of component displays the data for the column;
 *  specification of whether the column is editable, sortable, or resizeable;
 *  and specification of the text for the column header.
 *
 *  <p><strong>Notes:</strong><ul>
 *  <li>An AdvancedDataGridColumn only holds information about a column;
 *  it is not the parent of the item renderers in the column.</li>
 *  <li>If you specify an AdvancedDataGridColumn class without a <code>dataField</code>
 *  property, you must specify a <code>sortCompareFunction</code>
 *  property. Otherwise, sort operations may cause run-time errors.</li></ul> 
 *  </p>
 *
 *  @mxml
 *
 *  <p>You use the <code>&lt;mx.AdvancedDataGridcolumn&gt;</code> tag to configure a column
 *  of a AdvancedDataGrid control.
 *  You specify the <code>&lt;mx.AdvancedDataGridcolumn&gt;</code> tag as a child
 *  of the <code>columns</code> property in MXML.
 *  The <code>&lt;mx.AdvancedDataGridcolumn&gt;</code> tag inherits all of the 
 *  tag attributes of its superclass, and adds the following tag attributes:</p>
 *
 *  <pre>
 *  &lt;mx:AdvancedDataGridColumn
 *  <b>Properties </b>
 *    dataField=""<i>No default</i>""
 *    dataTipField=""<i>No default</i>""
 *    dataTipFunction=""<i>No default</i>""
 *    editable=""true|false""
 *    editorDataField=""text""
 *    editorHeightOffset=""0""
 *    editorUsesEnterKey=""false|true""
 *    editorWidthOffset=""0""
 *    editorXOffset=""0""
 *    editorYOffset=""0""
 *    formatter=""null""
 *    headerRenderer=""AdvancedDataGridHeaderRenderer""
 *    headerText=""<i>No default</i>""
 *    headerWordWrap=""undefined""
 *    imeMode=""null""
 *    itemEditor=""TextInput""
 *    itemRenderer=""AdvancedDataGridItemRenderer""
 *    labelFunction=""<i>No default</i>""
 *    minWidth=""20""
 *    rendererIsEditor=""false|true""
 *    resizable=""true|false""
 *    showDataTips=""false|true""
 *    sortable=""true|false""
 *    sortCompareFunction=""<i>No default</i>""
 *    sortDescending=""false|true""
 *    styleFunction=""<i>No default</i>""
 *    visible=""true|false""
 *    width=""100""
 *    wordWrap=""false|true""
 * 
 *  <b>Styles</b>
 *    backgroundColor=""0xFFFFFF""
 *    color=""<i>No default.</i>""
 *    disabledColor=""0xAAB3B3""
 *    fontAntiAliasType=""advanced""
 *    fontFamily=""<i>No default</i>""
 *    fontGridFitType=""pixel""
 *    fontSharpness=""0""
 *    fontSize=""<i>No default</i>""
 *    fontStyle=""normal|italic""
 *    fontThickness=""0""
 *    fontWeight=""normal|bold""
 *    headerStyleName=""<i>No default</i>""
 *    kerning=""false|true""
 *    letterSpacing=""0""
 *    paddingLeft=""0""
 *    paddingRight=""0""
 *    textAlign=""right|center|left""
 *    textDecoration=""none|underline""
 *    textIndent=""0""
 *  /&gt;
 *  </pre>
 *
 *  @see mx.controls.AdvancedDataGrid
 *
 *  @see mx.styles.CSSStyleDeclaration
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Royale 0.9.3
 *  @royalesuppresspublicvarwarning
 */
public class AdvancedDataGridColumn extends DataGridColumn
{//extends CSSStyleDeclaration implements IIMESupport
    //include ""../../core/Version.as"";
    
    //--------------------------------------------------------------------------
    //
    //  Class variables
    //
    //--------------------------------------------------------------------------
    //----------------------------------
    //  embeddedFontRegistry
    //----------------------------------

   // private static var noEmbeddedFonts:Boolean;

    /**
     *  @private
     *  Storage for the embeddedFontRegistry property.
     *  This gets initialized on first access,
     *  not at static initialization time, in order to ensure
     *  that the Singleton registry has already been initialized.
     */
   // private static var _embeddedFontRegistry:IEmbeddedFontRegistry;

    /**
     *  @private
     *  A reference to the embedded font registry.
     *  Single registry in the system.
     *  Used to look up the moduleFactory of a font.
    */
    /* private static function get embeddedFontRegistry():IEmbeddedFontRegistry
    {
        if (!_embeddedFontRegistry && !noEmbeddedFonts)
        {
            try
            {
                _embeddedFontRegistry = IEmbeddedFontRegistry(
                    Singleton.getInstance(""mx.core::IEmbeddedFontRegistry""));
            }
            catch (e:Error)
            {
                noEmbeddedFonts = true;
            }
        }

        return _embeddedFontRegistry;
    }
    */

    private static var _defaultItemEditorFactory:IFactory;
    
    mx_internal static function get defaultItemEditorFactory():IFactory
    {
        if (!_defaultItemEditorFactory)
            _defaultItemEditorFactory = new ClassFactory(TextInput);
        return _defaultItemEditorFactory;
    }
    
    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------

    /**
     *  Constructor.
     *
     *  @param columnName The name of the field in the data provider 
     *  associated with the column, and the text for the header cell of this 
     *  column.  This is equivalent to setting the <code>dataField</code>
     *  and <code>headerText</code> properties.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public function AdvancedDataGridColumn(columnName:String = null)
    {
        super(columnName);

      /*   if (columnName)
        {
            dataField = columnName;
            headerText = columnName;
        } */
    }
    
    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------

   // mx_internal var list:UIBase; //BaseEx;
    
    /**
     *  @private
     */
   // mx_internal var explicitWidth:Number;

    /**
     *  @private
     * Holds the last recorded value of the module factory used to create the font.
     */
   // private var oldEmbeddedFontContext:IFlexModuleFactory = null;

    /**
     *  @private
     * 
     *  true if font properties do not need to be set.
     */
   // private var fontPropertiesSet:Boolean = false;
    
    /**
     *  @private
     * True if createInFontContext has been called.
     */
   // private var hasFontContextBeenSaved:Boolean = false;
    
    // preferred width is the number we should use when measuring
    // regular width will be changed if we shrink columns to fit.
   // mx_internal var preferredWidth:Number = 100;
    
    //--------------------------------------------------------------------------
    //
    //  Properties
    //
    //--------------------------------------------------------------------------
    
    
    // ------------------------------------------------
    //  fontWeight
    // ------------------------------------------------
	
    public function get fontWeight():String
    {
	return ""normal"";
    }
    public function set fontWeight(value:String):void
    {
    }
    
    // ------------------------------------------------
    //  fontSize
    // ------------------------------------------------
	
    public function get fontSize():Number
    {
	return 11;
    }
    public function set fontSize(value:Number):void
    {
    }
    
    // ------------------------------------------------
    //  color
    // ------------------------------------------------
	
    public function get color():uint
    {
	return 0x0B333C;
    }
    public function set color(value:uint):void
    {
    }
    
    //----------------------------------
    //  sortDescending
    //----------------------------------

    /**
     *  Indicates whether the column sort is
     *  in ascending order, <code>false</code>, 
     *  or descending order, <code>true</code>.
     *  
     *  @default false
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
   // public var sortDescending:Boolean = false;
    //----------------------------------
    //  dataTipField
    //----------------------------------

    /**
     *  @private
     *  Storage for the dataTipField property.
     */
  /*   private var _dataTipField:String;

    [Bindable(""dataTipFieldChanged"")]
    [Inspectable(category=""Advanced"", defaultValue=""label"")]
 */
    /**
     *  The name of the field in the data provider to display as the data tip. 
     *  By default, the AdvancedDataGrid control looks for a property named 
     *  <code>label</code> on each data provider item and displays it.
     *  However, if the data provider does not contain a <code>label</code>
     *  property, you can set the <code>dataTipField</code> property to
     *  specify a different property.  
     *  For example, you could set the value to ""FullName"" when a user views a
     *  set of people's names included from a database.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
   /*  public function get dataTipField():String
    {
        return _dataTipField;
    } */

    /**
     *  @private
     */
   /*  public function set dataTipField(value:String):void
    {
        _dataTipField = value;

        if (owner)
        {
            owner.invalidateList();
        }

        dispatchEvent(new Event(""dataTipChanged""));
    } */

    //----------------------------------
    //  dataTipFunction
    //----------------------------------

    /**
     *  @private
     *  Storage for the dataTipFunction property.
     */
    /* private var _dataTipFunction:Function;

    [Bindable(""dataTipFunctionChanged"")]
    [Inspectable(category=""Advanced"")] */

    /**
     *  Specifies a callback function to run on each item of the data provider 
     *  to determine its data tip.
     *  This property is used by the <code>itemToDataTip()</code> method.
     * 
     *  <p>By default, the control looks for a property named <code>label</code>
     *  on each data provider item and displays it as its dataTip.
     *  However, some data providers do not have a <code>label</code> property 
     *  or another property that you can use for displaying data 
     *  in the rows.
     *  For example, you might have a data provider that contains a lastName 
     *  and firstName fields, but you want to display full names as the dataTip.
     *  You can specify a function to the <code>dataTipFunction</code> property 
     *  that returns a single String containing the value of both fields. You 
     *  can also use the <code>dataTipFunction</code> property for handling 
     *  formatting and localization.</p>
     * 
     *  <p>The function must take a single Object parameter, and return a String. 
     *  For the header cell of a column, the Object parameter is of type AdvancedDataGridColumn.
     *  For table cells, the Object parameter contains the data provider element for the cell.</p>
     *
     *  <p>Shown below is an example implementation of the function. 
     *  For the header cell, return ""Column Name"".
     *  For the table cells, return the name property of the Object:</p>
     *  <pre>
     *  private function tipFunc(value:Object):String
     *  {
     *      if (value is AdvancedDataGridColumn)
     *          return ""Column Name"";
     *                 
     *      // Use the 'name' property of the data provider element.
     *      return ""Name: "" + value[""name""];
     *  }</pre>
     * 
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
   /*  public function get dataTipFunction():Function
    {
        return _dataTipFunction;
    } */

    /**
     *  @private
     */
    /* public function set dataTipFunction(value:Function):void
    {
        _dataTipFunction = value;

        if (owner)
        {
            owner.invalidateList();
        }

        dispatchEvent(new Event(""labelFunctionChanged""));
    } */
    
    //----------------------------------
    //  draggable
    //----------------------------------

   // [Inspectable(category=""General"")]

    /**
     *  A flag that indicates whether the user is allowed to drag
     *  the column to a new position
     *  If <code>true</code>, the user can drag the 
     *  the column headers to a new position
     *
     *  @default true
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    //public var draggable:Boolean = true;

    //----------------------------------
    //  editable
    //----------------------------------

    //[Inspectable(category=""General"")]

    /**
     *  A flag that indicates whether the items in the column are editable.
     *  If <code>true</code>, and the AdvancedDataGrid's <code>editable</code>
     *  property is also <code>true</code>, the items in a column are 
     *  editable and can be individually edited
     *  by clicking an item or by navigating to the item with the 
     *  Tab and Arrow keys.
     *
     *  @default true
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    //public var editable:Boolean = true;

    //----------------------------------
    //  itemEditor
    //----------------------------------

    [Inspectable(category=""General"")]

    /**
     *  A class factory for the instances of the item editor to use for the 
     *  column, when it is editable.
     *
     *  <p>The default value is the mx.controls.TextInput control.</p>
     *
     *  @see mx.controls.TextInput
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var itemEditor:IFactory = defaultItemEditorFactory;

    //----------------------------------
    //  editorDataField
    //----------------------------------

    [Inspectable(category=""General"")]

    /**
     *  The name of the property of the item editor that contains the new
     *  data for the list item.
     *  For example, the default <code>itemEditor</code> is
     *  TextInput, so the default value of the <code>editorDataField</code> 
     *  property is <code>""text""</code>, which specifies the 
     *  <code>text</code> property of the TextInput control.
     *
     *  @default ""text""
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var editorDataField:String = ""text"";

    //----------------------------------
    //  editorHeightOffset
    //----------------------------------

    [Inspectable(category=""General"", defaultValue=""0"")]

    /**
     *  The height of the item editor, in pixels, relative to the size of the 
     *  item renderer.  This property can be used to make the editor overlap
     *  the item renderer by a few pixels to compensate for a border around the
     *  editor.  
     *  Note that changing these values while the editor is displayed
     *  will have no effect on the current editor, but will affect the next
     *  item renderer that opens an editor.
     *
     *  @default 0
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var editorHeightOffset:Number = 0;

    //----------------------------------
    //  editorWidthOffset
    //----------------------------------

    //[Inspectable(category=""General"", defaultValue=""0"")]

    /**
     *  The width of the item editor, in pixels, relative to the size of the 
     *  item renderer.  This property can be used to make the editor overlap
     *  the item renderer by a few pixels to compensate for a border around the
     *  editor.
     *  Note that changing these values while the editor is displayed
     *  will have no effect on the current editor, but will affect the next
     *  item renderer that opens an editor.
     *
     *  @default 0
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var editorWidthOffset:Number = 0;

    //----------------------------------
    //  editorXOffset
    //----------------------------------

   // [Inspectable(category=""General"", defaultValue=""0"")]

    /**
     *  The x location of the upper-left corner of the item editor,
     *  in pixels, relative to the upper-left corner of the item.
     *  This property can be used to make the editor overlap
     *  the item renderer by a few pixels to compensate for a border around the
     *  editor.
     *  Note that changing these values while the editor is displayed
     *  will have no effect on the current editor, but will affect the next
     *  item renderer that opens an editor.
     * 
     *  @default 0
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var editorXOffset:Number = 0;

    //----------------------------------
    //  editorYOffset
    //----------------------------------

    //[Inspectable(category=""General"", defaultValue=""0"")]

    /**
     *  The y location of the upper-left corner of the item editor,
     *  in pixels, relative to the upper-left corner of the item.
     *  This property can be used to make the editor overlap
     *  the item renderer by a few pixels to compensate for a border around the
     *  editor.
     *  Note that changing these values while the editor is displayed
     *  will have no effect on the current editor, but will affect the next
     *  item renderer that opens an editor.
     *
     *  @default 0
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var editorYOffset:Number = 0;

    //----------------------------------
    //  editorUsesEnterKey
    //----------------------------------

    //[Inspectable(category=""General"", defaultValue=""false"")]

    /**
     *  A flag that indicates whether the item editor uses Enter key.
     *  If <code>true</code> the item editor uses the Enter key and the
     *  AdvancedDataGrid will not look for the Enter key and move the editor in
     *  response.
     *  Note that changing this value while the editor is displayed
     *  will have no effect on the current editor, but will affect the next
     *  item renderer that opens an editor.
     *
     *  @default false
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public var editorUsesEnterKey:Boolean = false;
    
    //----------------------------------
    //  headerRenderer
    //----------------------------------

    /**
     *  @private
     *  Storage for the headerRenderer property.
     */
    private var _headerRenderer:IFactory;

    [Bindable(""headerRendererChanged"")]
    [Inspectable(category=""Other"")]

    /**
     *  The class factory for item renderer instances that display the 
     *  column header for the column.
     *  You can specify a drop-in item renderer,
     *  an inline item renderer, or a custom item renderer component as the 
     *  value of this property.
     *
     *  <p>The default item renderer is the AdvancedDataGridItemRenderer class,
     *  which displays the item data as text. </p>
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    override public function get headerRenderer():IFactory
    {
        return _headerRenderer;
    }

    /**
     *  @private
     */
    override public function set headerRenderer(value:IFactory):void
    {
        _headerRenderer = value;

        // rebuild the headers
       /*  if (owner)
        {
            owner.invalidateList();
            owner.columnRendererChanged(this);
        }

        dispatchEvent(new Event(""headerRendererChanged"")); */
    }


    //----------------------------------
    //  headerWordWrap
    //----------------------------------

    /**
     *  @private
     *  Storage for the headerWordWrap property.
     */
    private var _headerWordWrap:*;

    [Inspectable(category=""Advanced"")]

    /**
     *  Set to <code>true</code> to wrap the text in the column header 
     *  if it does not fit on one line.
     *  If <code>undefined</code>, the AdvancedDataGrid control's <code>wordWrap</code> property 
     *  is used. 
     *  This property overrides the <code>headerWordWrap</code> property of 
     *  the AdvancedDataGrid control.
     *
     *  @default undefined
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public function get headerWordWrap():*
    {
        return _headerWordWrap;
    }

    /**
     *  @private
     */
    public function set headerWordWrap(value:*):void
    {
        _headerWordWrap = value;

       /*  if (owner)
        {
            owner.invalidateList();
        } */
    }
    
    //----------------------------------
    //  enableIME
    //----------------------------------
    
    /**
     *  A flag that indicates whether the IME should
     *  be enabled when the component receives focus.
     *
     *  If an editor is up, it will set enableIME
     *  accordingly.
     *
     *  @langversion 3.0
     *  @playerversion Flash 10
     *  @playerversion AIR 1.5
     *  @productversion Flex 4
     */
   /*  public function get enableIME():Boolean
    {
        return false;
    } */

    //----------------------------------
    //  imeMode
    //----------------------------------

    /**
     *  @private
     *  Storage for the imeMode property.
     */
   /*  private var _imeMode:String;

    [Inspectable(category=""Other"")] */

    /**
     *  Specifies the IME (input method editor) mode. 
     *  The IME mode enables users to enter text in Chinese, Japanese, and Korean.  
     *  Flex sets the IME mode when the <code>itemFocusIn</code> event occurs, 
     *  and sets it back
     *  to the previous value when the <code>itemFocusOut</code> event occurs. 
     *  The flash.system.IMEConversionMode class defines constants for 
     *  the valid values for this property.  
     *
     *  <p>The default value is null, in which case it uses the value of the 
     *  AdvancedDataGrid control's <code>imeMode</code> property.</p>
     *
     *  @see flash.system.IMEConversionMode
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    /* public function get imeMode():String
    {
        return _imeMode;
    }
 */
    /**
     *  @private
     */
   /*  public function set imeMode(value:String):void
    {
        _imeMode = value;
    } */


   /* //----------------------------------
    //  resizable
    //----------------------------------

    [Inspectable(category=""General"")]

    /!**
     *  Set to <code>true</code> if the user is allowed to resize
     *  the width of the column.
     *  If <code>true</code>, the user can drag the grid lines between 
     *  the column headers to resize the column. 
     *
     *  @default true
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     *!/
    public var resizable:Boolean = true;

    //----------------------------------
    //  showDataTips
    //----------------------------------

    /!**
     *  @private
     *  Storage for the showDataTips property.
     *!/
    private var _showDataTips:*;

    [Inspectable(category=""Advanced"")]

    /!**
     *  Set to <code>true</code> to show data tips in the column.
     *  If <code>true</code>, datatips are displayed for text in the rows. Datatips
     *  are tooltips designed to show the text that is too long for the row.
     *
     *  @default false
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     *!/
    public function get showDataTips():*
    {
        return _showDataTips;
    }

    /!**
     *  @private
     *!/
    public function set showDataTips(value:*):void
    {
        _showDataTips = value;

       /!*  if (owner)
        {
            owner.invalidateList();
        } *!/
    }

    //----------------------------------
    //  sortable
    //----------------------------------

    [Inspectable(category=""General"")]

    /!**
     *  Set to <code>true</code> to indicate that the user can click on the
     *  header of this column to sort the data provider.
     *  If this property and the AdvancedDataGrid <code>sortableColumns</code> property 
     *  are both <code>true</code>, the AdvancedDataGrid control dispatches a 
     *  <code>headerRelease</code> event when a user releases the mouse button 
     *  on this column's header. 
     *  If no other handler calls the <code>preventDefault()</code> method on
     *  the <code>headerRelease</code> event, the <code>dataField</code>
     *  property or <code>sortCompareFunction</code> in the column is used 
     *  to reorder the items in the data provider.
     * 
     *  @default true
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     *!/
    public var sortable:Boolean = true;

    //----------------------------------
    //  sortCompareFunction
    //----------------------------------

    /!**
     *  @private
     *  Storage for the sortCompareFunction property.
     *!/
    private var _sortCompareFunction:Function;

    [Bindable(""sortCompareFunctionChanged"")]
    [Inspectable(category=""Advanced"")]

    /!**
     *
     *  A callback function that gets called when sorting the data in
     *  the column.  If this property is not specified, the sort tries
     *  to use a basic string or number sort on the data.
     *  If the data is not a string or number or if the <code>dataField</code>
     *  property is not a valid property of the data provider, the sort does
     *  not work or will generate an exception.
     *  If you specify a value of the <code>labelFunction</code> property,
     *  you typically also provide a function to the <code>sortCompareFunction</code> property,
     *  unless sorting is not allowed on this column. 
     *  That means you specify a function when the value from the column's <code>dataField</code> 
     *  does not sort in the same way as the computed value from the <code>labelFunction</code> property.
     *
     *  <p>The AdvancedDataGrid control uses this function to sort the elements of the data
     *  provider collection. The function signature of
     *  the callback function takes two parameters and has the following form:</p>
     *
     *  <pre>mySortCompareFunction(obj1:Object, obj2:Object):int </pre>
     *
     *  <p><code>obj1</code> &#x2014; A data element to compare.</p>
     * 
     *  <p><code>obj2</code> &#x2014; Another data element to compare with <code>obj1</code>.</p>
     * 
     *  <p>The function should return a value based on the comparison
     *  of the objects: </p>
     *  <ul>
     *    <li>-1 if obj1 should appear before obj2 in ascending order. </li>
     *    <li>0 if obj1 = obj2. </li>
     *    <li>1 if obj1 should appear after obj2 in ascending order.</li>
     *  </ul>
     * 
     *  <p><strong>Note:</strong> The <code>obj1</code> and
     *  <code>obj2</code> parameters are entire data provider elements and not
     *  just the data for the item.</p>
     *
     *  @default null
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     *!/
    public function get sortCompareFunction():Function
    {
        return _sortCompareFunction;
    }

    /!**
     *  @private
     *!/
    public function set sortCompareFunction(value:Function):void
    {
        _sortCompareFunction = value;

      //  dispatchEvent(new Event(""sortCompareFunctionChanged""));
    }

*/
    //----------------------------------
    //  sortCompareType
    //----------------------------------

    /**
     *  @private
     */
    //private var _sortCompareType:String;

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 11.8
     *  @playerversion AIR 3.8
     *  @productversion Flex 4.11
     */
    /* [Bindable(""sortCompareTypeChanged"")]
    public function get sortCompareType():String
    {
        return _sortCompareType;
    } */

    /**
     *  @private
     */
   /*  public function set sortCompareType(value:String):void
    {
        if (_sortCompareType != value)
        {
            _sortCompareType = value;
            dispatchEvent(new Event(""sortCompareTypeChanged""));
        }
    } */


   /* //----------------------------------
    //  visible
    //----------------------------------

    /!**
     *  @private
     *  Storage for the visible property.
     *!/
    private var _visible:Boolean = true;

    [Inspectable(category=""General"", defaultValue=""true"")]

    /!**
     *  If <code>true</code>, the column is visible.
     *  Set to <code>false</code> to hide the column.
     *
     *  @default true
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     *!/
    public function get visible():Boolean
    {
        return _visible;
    }

    /!**
     *  @private
     *!/
    public function set visible(value:Boolean):void
    {
        if (_visible != value)
        {
            _visible = value;

            if (owner)
            {
                (owner as AdvancedDataGrid).columnsInvalid();
                // columns invisible at init don't get a dataprovider so
                // force assignment by faking a dp change
                (owner as AdvancedDataGrid).model.dispatchEvent(new Event(""dataProviderChanged""));

                //owner.invalidateProperties();
                //owner.invalidateSize();
                //owner.invalidateList();
            }
        }
    }*/



    //----------------------------------
    //  styleFunction
    //----------------------------------

    /**
     * @private
     */
     private var _styleFunction:Function;

    /**
     *  A callback function that is called when rendering each cell. 
     *  The signature of the function should be:
     *  
     *  <pre>function myStyleFunction(data:Object, column:AdvancedDataGridColumn):Object</pre>
     *
     *  <p><code>data</code> - data object associated with the item being rendered.</p>
     *  <p><code>column</code> - AdvancedDataGridColumn instance with 
     *  which the item renderer is associated.</p>
     *
     *  <p>The return value should be a object with styles as properties
     *   having the required values. 
     *   For example: </p>
     * 
     *  <pre>{ color:0xFF0000, fontWeight:""bold"" }</pre>
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
     public function get styleFunction():Function
     {
            return _styleFunction;
     }

    /**
     * @private
     */
     public function set styleFunction(value:Function):void
     {
            _styleFunction = value;

            /* if (owner)
                owner.invalidateDisplayList(); */
     }


    //----------------------------------
    //  formatter
    //----------------------------------

    /**
     *  @private
     */
    //private var _formatter:IFormatter;

    /**
     *  An instance of a subclasses of mx.formatters.Formatter. 
     *  The control use this class to format the column text.
     *
     *  @default null
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
   /*  public function get formatter():IFormatter
    {
        return _formatter;
    } */

    /**
     *  @private
     */
    /* public function set formatter(value:IFormatter):void
    {
        _formatter = value;
        
        if (owner)
            owner.invalidateDisplayList();
    } */

    //--------------------------------------------------------------------------
    //
    //  Overridden methods
    //
    //--------------------------------------------------------------------------

    /**
     *  @private
     */
    /* override mx_internal function addStyleToProtoChain(
                                chain:Object, target:DisplayObject, filterMap:Object = null):Object
    {
        var parentGrid:AdvancedDataGridBaseEx = owner;
        var item:IListItemRenderer = IListItemRenderer(target);

        chain = super.addStyleToProtoChain(chain, target);
        
        // If the target data is a AdvancedDataGridColumn and has a data
        // field in its data, then it is a header so add the
        // AdvancedDataGrid.headerStyleName object to the head of the proto chain.
        if (item.data && (item.data is AdvancedDataGridColumn))
        {
            var s:Object;

            var headerStyleName:Object =
                parentGrid.getStyle(""headerStyleName"");
            if (headerStyleName)
            {
                if (headerStyleName is String)
                {
                    chain = addStylesToProtoChain(String(headerStyleName), chain, target);
                }

                if (headerStyleName is CSSStyleDeclaration)
                    chain = headerStyleName.addStyleToProtoChain(chain, target);
            }

            headerStyleName = getStyle(""headerStyleName"");
            if (headerStyleName)
            {
                if (headerStyleName is String)
                {
                    chain = addStylesToProtoChain(String(headerStyleName), chain, target);
                }

                if (headerStyleName is CSSStyleDeclaration)
                    chain = headerStyleName.addStyleToProtoChain(chain, target);
            }
        }
        
        // save the current font context
        if (!fontPropertiesSet)
        {
            fontPropertiesSet = true;
            saveFontContext(owner ? owner.moduleFactory : null);        
        }

        return chain;
    } */

    /**
     *  @private
     */
    /* override public function setStyle(styleProp:String, value:*):void
    {
        fontPropertiesSet = false;
        
        var oldValue:Object = getStyle(styleProp);
        var regenerate:Boolean = false;

        // If this AdvancedDataGridColumn didn't previously have a factory, defaultFactory, or
        // overrides object, then this AdvancedDataGridColumn hasn't been added to the item
        // renderers proto chains.  In that case, we need to regenerate all the item
        // renderers proto chains.
        if (factory == null &&
            defaultFactory == null &&
            !overrides &&
            (oldValue !== value)) // must be !==
        {
            regenerate = true;
        }

        super.setLocalStyle(styleProp, value);

        // The default implementation of setStyle won't always regenerate
        // the proto chain when headerStyleName is set, and we need to make sure
        // that they are regenerated
        if (styleProp == ""headerStyleName"")
        {
            if (owner)
            {
                owner.regenerateStyleCache(true);
                owner.notifyStyleChangeInChildren(""headerStyleName"", true);
            }
            return;
        }

        if (owner)
        {
            if (regenerate)
            {
                owner.regenerateStyleCache(true);
            }
            
            if (hasFontContextChanged(owner.moduleFactory))
            {
                owner.columnRendererChanged(this);
            }

            owner.invalidateList();            
        }

    } */
	
	/**
	 * @private
	 */ 
	/* override public function get specificity():int
	{
		// Return 10 as there is a sorting mechanism based on specificity now
		// and there could be ancestor specificity also!!
		return 10;
	} */

    //--------------------------------------------------------------------------
    //
    //  Methods
    //
    //--------------------------------------------------------------------------
    
    /**
     *  @private
     *  Internal function to allow the AdvancedDataGrid to set the width of the
     *  column without locking it as an explicitWidth
    mx_internal function setWidth(value:Number):void
    {
        _width = value;
    }
     */
    
    /**
     * @private
     *  
     * Apply column's Formatter if present.
     *  
     */
    /* private function applyFormatting(data:String):String
    {
        if (formatter != null && data != null)
        {
            var label:String = formatter.format(data);

            // Silently ignore formatter errors. For example, errors occur when
            // the property corresponding to the dataField is not present in the
            // row object i.e. it'll be empty and it's not anybody's fault that
            // it's an error.
            const mxFormatter:Formatter = formatter as Formatter;
            if (mxFormatter && mxFormatter.error)
                return null;

            return label;
        }
        else
        {
            return data;
        }
    } */

    /**
     *  Returns the String that the item renderer displays for the given data object.
     *  If the AdvancedDataGridColumn or its AdvancedDataGrid control 
     *  has a non-null <code>labelFunction</code> 
     *  property, it applies the function to the data object. 
     *  Otherwise, the method extracts the contents of the field specified by the 
     *  <code>dataField</code> property, or gets the string value of the data object.
     *  If the method cannot convert the parameter to a String, it returns a
     *  single space.
     *
     *  @param data Object to be rendered.
     *
     *  @param withFormatting It <code>true</code> specifies to return 
     *  the String with any formatting applied to it.
     * 
     *  @return Displayable String based on the data.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    /* public function itemToLabel(data:Object, withFormatting:Boolean=true):String
    {
        var label:String = itemToLabelWithoutFormatting(data);
        if (withFormatting)
            return applyFormatting(label);
        return label;
    } */

    /**
     *  @private
     *  
     *  This is the original AdvancedDataGrid.itemToLabel() that has been wrapped with applyFormatting()
     *  
     */
    /* private function itemToLabelWithoutFormatting(data:Object):String
    {
        var headerInfo:AdvancedDataGridHeaderInfo  = owner.mx_internal::getHeaderInfo(this);
        // In case of Column grouping, when a column has a parent with dataField/labelFunction set, this column is
        // supposed to take value from what its parent supplies it
		if (headerInfo != null && headerInfo.internalLabelFunction != null)
            data = headerInfo.internalLabelFunction(data, this);
   
        if (!data)
            return "" "";

        if (labelFunction != null)
            return labelFunction(data, this);

        if (owner.labelFunction != null)
            return owner.labelFunction(data, this);

        if (typeof(data) == ""object"" || typeof(data) == ""xml"")
        {
			if (dataField != null && dataField in data)
	            data = data[dataField];
			else
				return "" ""; // stops ""[object Object]"" showing
        }

        if (data is String)
            return String(data);

        try
        {
            return data.toString();
        }
        catch(e:Error)
        {
        }

        return "" "";
    } */

    /**
     *  Returns a String that the item renderer displays as the data tip for the given data object,
     *  based on the <code>dataTipField</code> and <code>dataTipFunction</code> properties.
     *  If the method cannot convert the parameter to a String, it returns a
     *  single space.
     * 
     *  <p>This method is for use by developers who are creating subclasses 
     *  of the AdvancedDataGridColumn class.
     *  It is not for use by application developers.</p>
     *
     *  @param data Object to be rendered.
     *
     *  @return Displayable String based on the data.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    /* public function itemToDataTip(data:Object):String
    {
        if (dataTipFunction != null)
            return dataTipFunction(data);

        if (owner.dataTipFunction != null)
            return owner.dataTipFunction(data);

        // for header items, return the header text
        if (data is AdvancedDataGridColumn)
            return AdvancedDataGridColumn(data).headerText;
        
        if (typeof(data) == ""object"" || typeof(data) == ""xml"")
        {
            var field:String = dataTipField;
            if (!field)
                field = owner.dataTipField;

            if (field != null)
			{
				if (field in data && data[field] != null)
					data = data[field];
			}
            else if (dataField != null)
			{
				if (dataField in data && data[dataField] != null)
	                data = data[dataField];
				else
					data = null;  
			}
        }

        if (data is String)
            return String(data);

        try
        {
            return data.toString();
        }
        catch(e:Error)
        {
        }

        return "" "";
    } */
	
    /**
     * @private
     * 
     * Save the current font context to member fields.
     */
    /* private function saveFontContext(flexModuleFactory:IFlexModuleFactory):void
    {
        // Save for hasFontContextChanged()
        hasFontContextBeenSaved = true;
        var fontName:String = StringUtil.trimArrayElements(getStyle(""fontFamily""), "","");
        var fontWeight:String = getStyle(""fontWeight"");
        var fontStyle:String = getStyle(""fontStyle"");
        var bold:Boolean = fontWeight == ""bold"";
        var italic:Boolean = fontStyle == ""italic"";
        oldEmbeddedFontContext = (noEmbeddedFonts || !embeddedFontRegistry) ? 
            null : 
            embeddedFontRegistry.getAssociatedModuleFactory(
                fontName, bold, italic, this, flexModuleFactory, 
                owner.systemManager);             
    } */
    
    /**
     *  @private
     *  Test if the current font context has changed
     *  since that last time saveFontContext() was called.
     */
    /* mx_internal function hasFontContextChanged(
                            flexModuleFactory:IFlexModuleFactory):Boolean
    {
        
        // If the font has not been saved yet, then return false,
        // the font context has not changed.
        if (!hasFontContextBeenSaved)
            return false;

        var fontName:String =
            StringUtil.trimArrayElements(getStyle(""fontFamily""), "","");
        var fontWeight:String = getStyle(""fontWeight"");
        var fontStyle:String = getStyle(""fontStyle"");
        
        // Check if the module factory has changed.
        var bold:Boolean = fontWeight == ""bold"";
        var italic:Boolean = fontStyle == ""italic"";
        var fontContext:IFlexModuleFactory = (noEmbeddedFonts || !embeddedFontRegistry) ? 
            null : 
            embeddedFontRegistry.getAssociatedModuleFactory(
                fontName, bold, italic, this, flexModuleFactory,
                owner.systemManager);
        return fontContext != oldEmbeddedFontContext;
    } */
	
	/**
	 *  @private
	 */
	/* private function addStylesToProtoChain(styles:String, chain:Object, target:DisplayObject):Object
	{
		var styleNames:Array = styles.split(/\\s+/);
		for (var c:int=0; c < styleNames.length; c++)
		{
			if (styleNames[c].length) 
			{
				var declaration:CSSStyleDeclaration = 
					owner.styleManager.getMergedStyleDeclaration(""."" + styleNames[c]);
				
				if (declaration)
					chain = declaration.addStyleToProtoChain(chain, target);
			}
		}
		return chain;
	} */

    /**
     *  @private
     * 
     *  Sets the properties of this Object to the given column.
     * 
     *  It sets only the required properties.
     *
     *  @param col AdvancedDataGridColumn in which the properties are to be set.
     *
     */
    /* protected function copyProperties(col:AdvancedDataGridColumn):void
    {
        // copy properties
        col.defaultFactory = this.defaultFactory; 
        col.editable = this.editable;
        col.editorDataField = this.editorDataField;
        col.editorHeightOffset = this.editorHeightOffset;
        col.editorUsesEnterKey = this.editorUsesEnterKey;
        col.editorWidthOffset = this.editorWidthOffset;
        col.editorXOffset =  this.editorXOffset;
        col.editorYOffset = this.editorYOffset;
        col.factory = this.factory;
        col.itemEditor =  this.itemEditor;
        col.rendererIsEditor = this.rendererIsEditor;
        col.resizable = this.resizable;
        col.sortable = this.sortable;
        col.sortDescending = this.sortDescending;
        col.dataField = this.dataField;
        col.dataTipField = this.dataTipField;
        col.dataTipFunction = this.dataTipFunction;
        col.formatter = this.formatter;
        col.headerRenderer = this.headerRenderer;
        col.headerText = this.headerText;
        col.headerWordWrap = this.headerWordWrap;
        col.imeMode = this.imeMode;
        col.itemRenderer = this.itemRenderer;
        col.labelFunction = this.labelFunction;
        col.minWidth = this.minWidth;
        col.showDataTips = this.showDataTips;
        col.sortCompareFunction = this.sortCompareFunction;
        col.styleFunction = this.styleFunction;
        col.visible = this.visible;
        col.width = this.width;
        col.wordWrap = this.wordWrap;
        
        // copy styles
        col.public::setStyle(""backgroundColor"",this.getStyle(""backgroundColor""));
        col.public::setStyle(""headerStyleName"",this.getStyle(""headerStyleName""));
        col.public::setStyle(""paddingLeft"",this.getStyle(""paddingLeft""));
        col.public::setStyle(""paddingRight"",this.getStyle(""paddingRight""));
        
        // copy text styles
        col.public::setStyle(""color"",this.getStyle(""color""));
        col.public::setStyle(""disabledColor"",this.getStyle(""disabledColor""));
        col.public::setStyle(""fontAntiAliasType"",this.getStyle(""fontAntiAliasType""));
        col.public::setStyle(""fontFamily"",this.getStyle(""fontFamily""));
        col.public::setStyle(""fontGridFitType"",this.getStyle(""fontGridFitType""));
        col.public::setStyle(""fontSharpness"",this.getStyle(""fontSharpness""));
        col.public::setStyle(""fontSize"",this.getStyle(""fontSize""));
        col.public::setStyle(""fontStyle"",this.getStyle(""fontStyle""));
        col.public::setStyle(""fontThickness"",this.getStyle(""fontThickness""));
        col.public::setStyle(""fontWeight"",this.getStyle(""fontWeight""));
        col.public::setStyle(""kerning"",this.getStyle(""kerning""));
        col.public::setStyle(""letterSpacing"",this.getStyle(""letterSpacing""));
        col.public::setStyle(""textAlign"",this.getStyle(""textAlign""));
        col.public::setStyle(""textDecoration"",this.getStyle(""textDecoration""));
        col.public::setStyle(""textIndent"",this.getStyle(""textIndent""));
    } */
    
    /**
     * 
     *  Clone this column and return a new Column with the 
     *  same properties and styles as this one.
     * 
     *  It does not set all the available properties
     *
     *  @return col AdvancedDataGridColumn.
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Royale 0.9.3
     */
    public function clone():AdvancedDataGridColumn
    {
        // make a new column
        var col:AdvancedDataGridColumn = new AdvancedDataGridColumn();
        
		// copy the properties
      //copyProperties(col);
        
        return col;
    }
}

}
",12386,True,2654.6651581336637,median
"/*

  ClipWindow.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
  
*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
}

u8g2_uint_t x = 0;

void loop(void) {
  if ( x == 0 )
    x = 40;
  else
    x--;
    
  u8g2.setFont(u8g2_font_ncenB10_tr);
  u8g2.firstPage();
  do {
  
    /* assign a clip window and draw some text into it */
    u8g2.setClipWindow(35, 11, 74, 27);  /* upper left and lower right position */
    u8g2.drawStr(x,23,""U8g2 U8g2"");
    
    /* remove clip window, draw to complete screen */
    u8g2.setMaxClipWindow(); 
    u8g2.drawFrame(34, 10, 40, 18);
    
  } while ( u8g2.nextPage() );
  delay(10);
}

",16146,True,4928.098121370338,median
"/*

  UpdateArea.ino
  
  Demonstration for the UpdateDisplayArea command

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED
//U8G2_SSD1306_72X40_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD0323_OS128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD0323_OS128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 		// Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); 	 // Not tested
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_MAX7219_64X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_32X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_8X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_LS013B7DH03_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V


// End of constructor list

int16_t offset;				// current offset for the scrolling text
u8g2_uint_t width;			// pixel width of the scrolling text (must be lesser than 128 unless U8G2_16BIT is defined
const char *text = ""U8g2"";	// scroll this text from right to left

const uint8_t tile_area_x_pos = 2;	// Update area left position (in tiles)
const uint8_t tile_area_y_pos = 3;	// Update area upper position (distance from top in tiles)
const uint8_t tile_area_width = 12;
const uint8_t tile_area_height = 3;	// this will allow cour18 chars to fit into the area

const u8g2_uint_t pixel_area_x_pos = tile_area_x_pos*8;
const u8g2_uint_t pixel_area_y_pos = tile_area_y_pos*8;
const u8g2_uint_t pixel_area_width = tile_area_width*8;
const u8g2_uint_t pixel_area_height = tile_area_height*8;

void setup(void) {
  u8g2.begin();
    
  u8g2.clearBuffer();					// clear the internal memory
  u8g2.setFont(u8g2_font_helvR10_tr);	// choose a suitable font
  u8g2.drawStr(0,12,""UpdateDisplayArea"");	// write something to the internal memory
  
  // draw a frame, only the content within the frame will be updated
  // the frame is never drawn again, but will stay on the display
  u8g2.drawBox(pixel_area_x_pos-1, pixel_area_y_pos-1, pixel_area_width+2, pixel_area_height+2);
  
  u8g2.sendBuffer();					// transfer internal memory to the display
  
  u8g2.setFont(u8g2_font_courB18_tr);	// set the target font for the text width calculation
  width = u8g2.getUTF8Width(text);		// calculate the pixel width of the text
  offset = width+pixel_area_width;
  
  
}

void loop(void) {
  u8g2.clearBuffer();						// clear the complete internal memory

  // draw the scrolling text at current offset
  u8g2.setFont(u8g2_font_courB18_tr);		// set the target font
  u8g2.drawUTF8(
    pixel_area_x_pos-width+offset, 
    pixel_area_y_pos+pixel_area_height+u8g2.getDescent()-1, 
    text);								// draw the scolling text
  
  // now only update the selected area, the rest of the display content is not changed
  u8g2.updateDisplayArea(tile_area_x_pos, tile_area_y_pos, tile_area_width, tile_area_height);
      
  offset--;								// scroll by one pixel
  if ( offset == 0 )	
    offset = width+pixel_area_width;			// start over again
    
  delay(10);							// do some small delay
}

",16215,True,4869.599222284706,median
"/*

  Clock.ino
  
  Demonstrates a clock-like display with a very huge font.
  Also shows usage of u8x8_u8toa().

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list

void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
}

uint8_t m = 24;

void loop(void) {
  char m_str[3];
  strcpy(m_str, u8x8_u8toa(m, 2));		/* convert m to a string with two digits */
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_logisoso62_tn);
    u8g2.drawStr(0,63,""9"");
    u8g2.drawStr(33,63,"":"");
    u8g2.drawStr(50,63,m_str);
  } while ( u8g2.nextPage() );
  delay(1000);
  m++;
  if ( m == 60 )
    m = 0;
}

",16138,True,5020.86932063554,median
"// GxEPD2_MultiDisplayExample : Display Library example for SPI e-paper panels from Dalian Good Display and boards from Waveshare.
// Requires HW SPI and Adafruit_GFX. Caution: the e-paper panels require 3.3V supply AND data lines!
//
// Display Library based on Demo Example from Good Display: http://www.e-paper-display.com/download_list/downloadcategoryid=34&isMode=false.html
//
// Author: Jean-Marc Zingg
//
// Version: see library.properties
//
// Library: https://github.com/ZinggJM/GxEPD2

// Supporting Arduino Forum Topics:
// Waveshare e-paper displays with SPI: http://forum.arduino.cc/index.php?topic=487007.0
// Good Display ePaper for Arduino: https://forum.arduino.cc/index.php?topic=436411.0

// mapping suggestion from Waveshare SPI e-Paper to Wemos D1 mini
// BUSY -> D2, RST -> D4, DC -> D3, CS -> D8, CLK -> D5, DIN -> D7, GND -> GND, 3.3V -> 3.3V
// NOTE: connect 3.3k pull-down from D8 to GND if your board or shield has level converters
// NOTE for ESP8266: using SS (GPIO15) for CS may cause boot mode problems, use different pin in case, or 4k7 pull-down

// mapping suggestion from Waveshare SPI e-Paper to generic ESP8266
// BUSY -> GPIO4, RST -> GPIO2, DC -> GPIO0, CS -> GPIO15, CLK -> GPIO14, DIN -> GPIO13, GND -> GND, 3.3V -> 3.3V
// NOTE: connect 3.3k pull-down from GPIO15 to GND if your board or shield has level converters
// NOTE for ESP8266: using SS (GPIO15) for CS may cause boot mode problems, use different pin in case, or 3.3k pull-down

// mapping of Waveshare e-Paper ESP8266 Driver Board, new version (see GxEPD2_boards_added.h for old version)
// BUSY -> GPIO5, RST -> GPIO2, DC -> GPIO4, CS -> GPIO15, CLK -> GPIO14, DIN -> GPIO13, GND -> GND, 3.3V -> 3.3V
// NOTE for ESP8266: using SS (GPIO15) for CS may cause boot mode problems, add a 3.3k pull-down in case
//      the e-Paper ESP8266 Driver Board should have no boot mode issue, as it doesn't use level converters

// mapping suggestion for ESP32, e.g. LOLIN32, see .../variants/.../pins_arduino.h for your board
// NOTE: there are variants with different pins for SPI ! CHECK SPI PINS OF YOUR BOARD
// BUSY -> 4, RST -> 16, DC -> 17, CS -> SS(5), CLK -> SCK(18), DIN -> MOSI(23), GND -> GND, 3.3V -> 3.3V

// mapping of Waveshare ESP32 Driver Board
// BUSY -> 25, RST -> 26, DC -> 27, CS-> 15, CLK -> 13, DIN -> 14
// NOTE: this board uses ""unusual"" SPI pins and requires re-mapping of HW SPI to these pins in SPIClass
//       see example GxEPD2_WS_ESP32_Driver.ino, it shows how this can be done easily

// new mapping suggestion for STM32F1, e.g. STM32F103C8T6 ""BluePill""
// BUSY -> A1, RST -> A2, DC -> A3, CS-> A4, CLK -> A5, DIN -> A7

// mapping suggestion for AVR, UNO, NANO etc.
// BUSY -> 7, RST -> 9, DC -> 8, CS-> 10, CLK -> 13, DIN -> 11

// base class GxEPD2_GFX can be used to pass references or pointers to the display instance as parameter
// enable GxEPD2_GFX base class
#define ENABLE_GxEPD2_GFX 1 

// uncomment next line to use class GFX of library GFX_Root instead of Adafruit_GFX
//#include <GFX.h>
// Note: if you use this with ENABLE_GxEPD2_GFX 1:
//       uncomment it in GxEPD2_GFX.h too, or add #include <GFX.h> before any #include <GxEPD2_GFX.h>
// !!!!  ============================================================================================ !!!!

#include <GxEPD2_BW.h>
#include <GxEPD2_3C.h>
#include <Fonts/FreeMonoBold9pt7b.h>

// create display class instances for each display, each instance with different CS line, each instance with RST disabled,
// (or use separate RST pins for each display),
// each instance with different BUSY line, or BUSY lines or-ed to one pin
// disable reset line to disable cross resets by multiple instances

#if defined (ESP8266)
#define RST_PIN 0 // D3(0)
#define CS_1 SS // CS = D8(15)
#define CS_2 16 // CS = D0(16)
#define CS_3  5 // CS = D1(5)
// BUSY lines can be or-ed with diodes and pulldown register for displays with BUSY active HIGH
#define BUSY_H_x 4 // BUSY = D2(4)
// BUSY lines can be or-ed with diodes and pullup resistor for displays with BUSY active LOW
//#define BUSY_L_x 4 // BUSY = D2(4)
// select one and adapt to your mapping, can use full buffer size (full HEIGHT)
//GxEPD2_BW<GxEPD2_154, GxEPD2_154::HEIGHT> display1(GxEPD2_154(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEP015OC1 no longer available
GxEPD2_BW<GxEPD2_154_D67, GxEPD2_154_D67::HEIGHT> display1(GxEPD2_154_D67(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEH0154D67
//GxEPD2_BW<GxEPD2_154_T8, GxEPD2_154_T8::HEIGHT> display(GxEPD2_154_T8(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0154T8 152x152
//GxEPD2_BW<GxEPD2_154_M09, GxEPD2_154_M09::HEIGHT> display(GxEPD2_154_M09(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0154M09 200x200
//GxEPD2_BW<GxEPD2_154_M10, GxEPD2_154_M10::HEIGHT> display(GxEPD2_154_M10(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0154M10 152x152
GxEPD2_BW<GxEPD2_213, GxEPD2_213::HEIGHT> display2(GxEPD2_213(/*CS=*/ CS_2, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x));
//GxEPD2_BW<GxEPD2_213_B72, GxEPD2_213_B72::HEIGHT> display(GxEPD2_213_B72(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEH0213B72
//GxEPD2_BW<GxEPD2_213_B73, GxEPD2_213_B73::HEIGHT> display(GxEPD2_213_B73(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEH0213B73
//GxEPD2_BW<GxEPD2_213_flex, GxEPD2_213_flex::HEIGHT> display(GxEPD2_213_flex(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0213I5F
//GxEPD2_BW<GxEPD2_213_M21, GxEPD2_213_M21::HEIGHT> display(GxEPD2_213_M21(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0213M21
//GxEPD2_BW<GxEPD2_213_T5D, GxEPD2_213_T5D::HEIGHT> display(GxEPD2_213_T5D(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0213T5D
GxEPD2_BW<GxEPD2_290, GxEPD2_290::HEIGHT> display3(GxEPD2_290(/*CS=*/ CS_3, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x));
//GxEPD2_BW<GxEPD2_290_T5, GxEPD2_290_T5::HEIGHT> display(GxEPD2_290_T5(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW029T5
//GxEPD2_BW<GxEPD2_290_T5D, GxEPD2_290_T5D::HEIGHT> display(GxEPD2_290_T5D(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW029T5D
//GxEPD2_BW<GxEPD2_290_M06, GxEPD2_290_M06::HEIGHT> display(GxEPD2_290_M06(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW029M06
//GxEPD2_BW<GxEPD2_260, GxEPD2_260::HEIGHT> display(GxEPD2_260(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_270, GxEPD2_270::HEIGHT> display(GxEPD2_270(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_371, GxEPD2_371::HEIGHT> display(GxEPD2_371(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_420, GxEPD2_420::HEIGHT> display(GxEPD2_420(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_420_M01, GxEPD2_420_M01::HEIGHT> display(GxEPD2_420_M01(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW042M01
// can use only half buffer size
//GxEPD2_BW < GxEPD2_583, GxEPD2_583::HEIGHT / 2 > display(GxEPD2_583(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW < GxEPD2_583_T8, GxEPD2_583_T8::HEIGHT / 2 > display(GxEPD2_583_T8(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW < GxEPD2_750, GxEPD2_750::HEIGHT / 2 > display(GxEPD2_750(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW < GxEPD2_750_T7, GxEPD2_750_T7::HEIGHT / 2 > display(GxEPD2_750_T7(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW075T7 800x480
// 3-color e-papers
//GxEPD2_3C<GxEPD2_154c, GxEPD2_154c::HEIGHT> display(GxEPD2_154c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW0154Z04 no longer available
//GxEPD2_3C<GxEPD2_154_Z90c, GxEPD2_154_Z90c::HEIGHT> display(GxEPD2_154_Z90c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEH0154Z90
//GxEPD2_3C<GxEPD2_213c, GxEPD2_213c::HEIGHT> display(GxEPD2_213c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_213_Z19c, GxEPD2_213_Z19c::HEIGHT> display(GxEPD2_213_Z19c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW0213Z19
//GxEPD2_3C<GxEPD2_290c, GxEPD2_290c::HEIGHT> display(GxEPD2_290c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_290_Z13c, GxEPD2_290_Z13c::HEIGHT> display(GxEPD2_290_Z13c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEH029Z13
//GxEPD2_3C<GxEPD2_290_C90c, GxEPD2_290_C90c::HEIGHT> display(GxEPD2_290_C90c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEM029C90
//GxEPD2_3C<GxEPD2_270c, GxEPD2_270c::HEIGHT> display(GxEPD2_270c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
// can use only half buffer size
//GxEPD2_3C<GxEPD2_420c, GxEPD2_420c::HEIGHT / 2> display(GxEPD2_420c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
// can use only quarter buffer size
//GxEPD2_3C<GxEPD2_583c, GxEPD2_583c::HEIGHT / 4> display(GxEPD2_583c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_750c, GxEPD2_750c::HEIGHT / 4> display3(GxEPD2_750c(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C < GxEPD2_750c_Z08, GxEPD2_750c_Z08::HEIGHT / 4 > display(GxEPD2_750c_Z08(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW075Z08 800x480
#endif

#if defined(ESP32)
#define RST_PIN 16
#define CS_1 SS // CS = 5(SS)
#define CS_2  0 // CS = 0
#define CS_3  2 // CS = 2
#define CS_4 13 // CS = 13
// BUSY lines can be or-ed with diodes and pulldown register for displays with BUSY active HIGH
#define BUSY_H_x 4 // BUSY = 4
// BUSY lines can be or-ed with diodes and pullup resistor for displays with BUSY active LOW
#define BUSY_L_x 15 // BUSY = 15
// select one and adapt to your mapping, can use full buffer size (full HEIGHT)
//GxEPD2_BW<GxEPD2_154, GxEPD2_154::HEIGHT> display1(GxEPD2_154(/*CS=*/ CS_1, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEP015OC1 no longer available
GxEPD2_BW<GxEPD2_154_D67, GxEPD2_154_D67::HEIGHT> display1(GxEPD2_154_D67(/*CS=*/ CS_1, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEH0154D67
//GxEPD2_BW<GxEPD2_154_T8, GxEPD2_154_T8::HEIGHT> display(GxEPD2_154_T8(/*CS=*/ CS_1, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0154T8 152x152
//GxEPD2_BW<GxEPD2_154_M09, GxEPD2_154_M09::HEIGHT> display(GxEPD2_154_M09(/*CS=*/ CS_1, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0154M09 200x200
//GxEPD2_BW<GxEPD2_154_M10, GxEPD2_154_M10::HEIGHT> display(GxEPD2_154_M10(/*CS=*/ CS_1, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0154M10 152x152
GxEPD2_BW<GxEPD2_213, GxEPD2_213::HEIGHT> display2(GxEPD2_213(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x));
//GxEPD2_BW<GxEPD2_213_B72, GxEPD2_213_B72::HEIGHT> display(GxEPD2_213_B72(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEH0213B72
//GxEPD2_BW<GxEPD2_213_B73, GxEPD2_213_B73::HEIGHT> display(GxEPD2_213_B73(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEH0213B73
//GxEPD2_BW<GxEPD2_213_flex, GxEPD2_213_flex::HEIGHT> display(GxEPD2_213_flex(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0213I5F
//GxEPD2_BW<GxEPD2_213_M21, GxEPD2_213_M21::HEIGHT> display(GxEPD2_213_M21(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0213M21
//GxEPD2_BW<GxEPD2_213_T5D, GxEPD2_213_T5D::HEIGHT> display(GxEPD2_213_T5D(//*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW0213T5D
GxEPD2_BW<GxEPD2_290, GxEPD2_290::HEIGHT> display3(GxEPD2_290(/*CS=*/ CS_3, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x));
//GxEPD2_BW<GxEPD2_290_T5, GxEPD2_290_T5::HEIGHT> display(GxEPD2_290_T5(/*CS=*/ CS_1, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW029T5
//GxEPD2_BW<GxEPD2_290_T5D, GxEPD2_290_T5D::HEIGHT> display(GxEPD2_290_T5D(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW029T5D
//GxEPD2_BW<GxEPD2_290_M06, GxEPD2_290_M06::HEIGHT> display(GxEPD2_290_M06(/*CS=*/ CS_2, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_H_x)); // GDEW029M06
//GxEPD2_BW<GxEPD2_260, GxEPD2_260::HEIGHT> display(GxEPD2_260(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_270, GxEPD2_270::HEIGHT> display(GxEPD2_270(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_371, GxEPD2_371::HEIGHT> display(GxEPD2_371(/*CS=*/ CS_x, /*DC=D3*/ 0, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_420, GxEPD2_420::HEIGHT> display4(GxEPD2_420(/*CS=*/ CS_4, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_420_M01, GxEPD2_420_M01::HEIGHT> display(GxEPD2_420_M01(/*CS=*/ CS_4, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW042M01
//GxEPD2_BW<GxEPD2_583, GxEPD2_583::HEIGHT> display(GxEPD2_583(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_583_T8, GxEPD2_583_T8::HEIGHT> display(GxEPD2_583_T8(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4));
//GxEPD2_BW<GxEPD2_750, GxEPD2_750::HEIGHT> display(GxEPD2_750(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_BW<GxEPD2_750_T7, GxEPD2_750_T7::HEIGHT> display(GxEPD2_750_T7(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW075T7 800x480
// 3-color e-papers
//GxEPD2_3C<GxEPD2_154c, GxEPD2_154c::HEIGHT> display(GxEPD2_154c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW0154Z04 no longer available
//GxEPD2_3C<GxEPD2_154_Z90c, GxEPD2_154_Z90c::HEIGHT> display(GxEPD2_154_Z90c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEH0154Z90
//GxEPD2_3C<GxEPD2_213c, GxEPD2_213c::HEIGHT> display(GxEPD2_213c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_213_Z19c, GxEPD2_213_Z19c::HEIGHT> display(GxEPD2_213_Z19c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW0213Z19
//GxEPD2_3C<GxEPD2_290c, GxEPD2_290c::HEIGHT> display(GxEPD2_290c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_290_Z13c, GxEPD2_290_Z13c::HEIGHT> display(GxEPD2_290_Z13c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEH029Z13
//GxEPD2_3C<GxEPD2_290_C90c, GxEPD2_290_C90c::HEIGHT> display(GxEPD2_290_C90c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEM029C90
//GxEPD2_3C<GxEPD2_270c, GxEPD2_270c::HEIGHT> display(GxEPD2_270c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_420c, GxEPD2_420c::HEIGHT> display(GxEPD2_420c(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
GxEPD2_3C<GxEPD2_750c, GxEPD2_750c::HEIGHT> display4(GxEPD2_750c(/*CS=*/ CS_4, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x));
//GxEPD2_3C<GxEPD2_750c_Z08, GxEPD2_750c_Z08::HEIGHT> display(GxEPD2_750c_Z08(/*CS=*/ CS_x, /*DC=*/ 17, /*RST=*/ -1, /*BUSY=*/ BUSY_L_x)); // GDEW075Z08 800x480
#endif

// comment out unused bitmaps to reduce code space used
#include ""bitmaps/Bitmaps200x200.h"" // 1.54"" b/w
#include ""bitmaps/Bitmaps128x250.h"" // 2.13"" b/w
#include ""bitmaps/Bitmaps128x296.h"" // 2.9""  b/w
#include ""bitmaps/Bitmaps176x264.h"" // 2.7""  b/w
#include ""bitmaps/Bitmaps400x300.h"" // 4.2""  b/w
#include ""bitmaps/Bitmaps640x384.h"" // 7.5""  b/w
// 3-color
#include ""bitmaps/Bitmaps3c200x200.h"" // 1.54"" b/w/r
#include ""bitmaps/Bitmaps3c104x212.h"" // 2.13"" b/w/r
#include ""bitmaps/Bitmaps3c128x296.h"" // 2.9""  b/w/r
#include ""bitmaps/Bitmaps3c176x264.h"" // 2.7""  b/w/r
#include ""bitmaps/Bitmaps3c400x300.h"" // 4.2""  b/w/r

void setup()
{
  Serial.begin(115200);
  Serial.println();
  Serial.println(""setup"");

  // one common reset for all displays
  digitalWrite(RST_PIN, HIGH);
  pinMode(RST_PIN, OUTPUT);
  delay(20);
  digitalWrite(RST_PIN, LOW);
  delay(20);
  digitalWrite(RST_PIN, HIGH);
  delay(200);

  display1.init(115200); // enable diagnostic output on Serial
  display2.init(115200); // enable diagnostic output on Serial
  display3.init(115200); // enable diagnostic output on Serial
#if defined(ESP32)
  display4.init(115200); // enable diagnostic output on Serial
#endif
  // first update should be full refresh
  helloWorld(display1);
  helloWorld(display2);
  helloWorld(display3);
#if defined(ESP32)
  helloWorld(display4);
#endif
  delay(1000);
  // partial refresh mode can be used to full screen,
  // effective if display panel hasFastPartialUpdate
  helloFullScreenPartialMode(display1);
  helloFullScreenPartialMode(display2);
  helloFullScreenPartialMode(display3);
#if defined(ESP32)
  helloFullScreenPartialMode(display4);
#endif
  delay(1000);
  helloArduino(display1);
  helloArduino(display2);
  helloArduino(display3);
#if defined(ESP32)
  helloArduino(display4);
#endif
  delay(1000);
  helloEpaper(display1);
  helloEpaper(display2);
  helloEpaper(display3);
#if defined(ESP32)
  helloEpaper(display4);
#endif
  delay(1000);
  showFont(display1, ""FreeMonoBold9pt7b"", &FreeMonoBold9pt7b);
  showFont(display2, ""FreeMonoBold9pt7b"", &FreeMonoBold9pt7b);
  showFont(display3, ""FreeMonoBold9pt7b"", &FreeMonoBold9pt7b);
#if defined(ESP32)
  showFont(display4, ""FreeMonoBold9pt7b"", &FreeMonoBold9pt7b);
#endif
  delay(1000);
  drawBitmaps(display1);
  drawBitmaps(display2);
  drawBitmaps(display3);
#if defined(ESP32)
  drawBitmaps(display4);
#endif
//  if (display1.epd2.hasPartialUpdate)
//  {
//    showPartialUpdate(display1);
//    delay(1000);
//  } // else // on GDEW0154Z04 only full update available, doesn't look nice
  //drawCornerTest(display1);
  //showBox(display1, 16, 16, 48, 32, false);
  //showBox(display1, 16, 56, 48, 32, true);
  display1.powerOff();
  display2.powerOff();
  display3.powerOff();
  Serial.println(""setup done"");
}

void loop()
{
}


void helloWorld(GxEPD2_GFX& display)
{
  //Serial.println(""helloWorld"");
  display.setRotation(1);
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(GxEPD_BLACK);
  uint16_t x = (display.width() - 160) / 2;
  uint16_t y = display.height() / 2;
  display.setFullWindow();
  display.firstPage();
  do
  {
    display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.println(""Hello World!"");
  }
  while (display.nextPage());
  //Serial.println(""helloWorld done"");
}


void helloFullScreenPartialMode(GxEPD2_GFX& display)
{
  //Serial.println(""helloFullScreenPartialMode"");
  display.setPartialWindow(0, 0, display.width(), display.height());
  display.setRotation(1);
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(GxEPD_BLACK);
  display.firstPage();
  do
  {
    uint16_t x = (display.width() - 160) / 2;
    uint16_t y = display.height() / 2;
    display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.println(""Hello World!"");
    y = display.height() / 4;
    display.setCursor(x, y);
    display.println(""full screen"");
    y = display.height() * 3 / 4;
    if (display.width() <= 200) x = 0;
    display.setCursor(x, y);
    if (display.epd2.hasFastPartialUpdate)
    {
      display.println(""fast partial mode"");
    }
    else if (display.epd2.hasPartialUpdate)
    {
      display.println(""slow partial mode"");
    }
    else
    {
      display.println(""no partial mode"");
    }
  }
  while (display.nextPage());
  //Serial.println(""helloFullScreenPartialMode done"");
}


void helloArduino(GxEPD2_GFX& display)
{
  //Serial.println(""helloArduino"");
  display.setRotation(1);
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(display.epd2.hasColor ? GxEPD_RED : GxEPD_BLACK);
  uint16_t x = (display.width() - 160) / 2;
  uint16_t y = display.height() / 4;
  display.setPartialWindow(0, y - 14, display.width(), 20);
  display.firstPage();
  do
  {
    display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.println(""Hello Arduino!"");
  }
  while (display.nextPage());
  delay(1000);
  //Serial.println(""helloArduino done"");
}


void helloEpaper(GxEPD2_GFX& display)
{
  //Serial.println(""helloEpaper"");
  display.setRotation(1);
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(display.epd2.hasColor ? GxEPD_RED : GxEPD_BLACK);
  uint16_t x = (display.width() - 160) / 2;
  uint16_t y = display.height() * 3 / 4;
  display.setPartialWindow(0, y - 14, display.width(), 20);
  display.firstPage();
  do
  {
    display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.println(""Hello E-Paper!"");
  }
  while (display.nextPage());
  //Serial.println(""helloEpaper done"");
}


void showBox(GxEPD2_GFX& display, uint16_t x, uint16_t y, uint16_t w, uint16_t h, bool partial)
{
  //Serial.println(""showBox"");
  display.setRotation(1);
  if (partial)
  {
    display.setPartialWindow(x, y, w, h);
  }
  else
  {
    display.setFullWindow();
  }
  display.firstPage();
  do
  {
    display.fillScreen(GxEPD_WHITE);
    display.fillRect(x, y, w, h, GxEPD_BLACK);
  }
  while (display.nextPage());
  //Serial.println(""showBox done"");
}


void drawCornerTest(GxEPD2_GFX& display)
{
  display.setFullWindow();
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(GxEPD_BLACK);
  for (uint16_t r = 0; r <= 4; r++)
  {
    display.setRotation(r);
    display.firstPage();
    do
    {
      display.fillScreen(GxEPD_WHITE);
      display.fillRect(0, 0, 8, 8, GxEPD_BLACK);
      display.fillRect(display.width() - 18, 0, 16, 16, GxEPD_BLACK);
      display.fillRect(display.width() - 25, display.height() - 25, 24, 24, GxEPD_BLACK);
      display.fillRect(0, display.height() - 33, 32, 32, GxEPD_BLACK);
      display.setCursor(display.width() / 2, display.height() / 2);
      display.print(display.getRotation());
    }
    while (display.nextPage());
    delay(2000);
  }
}


void showFont(GxEPD2_GFX& display, const char name[], const GFXfont* f)
{
  display.setFullWindow();
  display.setRotation(0);
  display.setTextColor(GxEPD_BLACK);
  display.firstPage();
  do
  {
    drawFont(display, name, f);
  }
  while (display.nextPage());
}


//void drawFont(GxEPD2_GFX& display, const char name[], const GFXfont* f);


void drawFont(GxEPD2_GFX& display, const char name[], const GFXfont* f)
{
  //display.setRotation(0);
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setFont(f);
  display.setCursor(0, 0);
  display.println();
  display.println(name);
  display.println("" !\\""#$%&'()*+,-./"");
  display.println(""0123456789:;<=>?"");
  display.println(""@ABCDEFGHIJKLMNO"");
  display.println(""PQRSTUVWXYZ[\\\\]^_"");
  if (display.epd2.hasColor)
  {
    display.setTextColor(GxEPD_RED);
  }
  display.println(""`abcdefghijklmno"");
  display.println(""pqrstuvwxyz{|}~ "");
}


void showPartialUpdate(GxEPD2_GFX& display)
{
  // some useful background
  helloWorld(display);
  // use asymmetric values for test
  uint16_t box_x = 10;
  uint16_t box_y = 15;
  uint16_t box_w = 70;
  uint16_t box_h = 20;
  uint16_t cursor_y = box_y + box_h - 6;
  float value = 13.95;
  uint16_t incr = display.epd2.hasFastPartialUpdate ? 1 : 3;
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(GxEPD_BLACK);
  // show where the update box is
  for (uint16_t r = 0; r < 4; r++)
  {
    display.setRotation(r);
    display.setPartialWindow(box_x, box_y, box_w, box_h);
    display.firstPage();
    do
    {
      display.fillRect(box_x, box_y, box_w, box_h, GxEPD_BLACK);
      //display.fillScreen(GxEPD_BLACK);
    }
    while (display.nextPage());
    delay(2000);
    display.firstPage();
    do
    {
      display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
    }
    while (display.nextPage());
    delay(1000);
  }
  //return;
  // show updates in the update box
  for (uint16_t r = 0; r < 4; r++)
  {
    display.setRotation(r);
    display.setPartialWindow(box_x, box_y, box_w, box_h);
    for (uint16_t i = 1; i <= 10; i += incr)
    {
      display.firstPage();
      do
      {
        display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
        display.setCursor(box_x, cursor_y);
        display.print(value * i, 2);
      }
      while (display.nextPage());
      delay(500);
    }
    delay(1000);
    display.firstPage();
    do
    {
      display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
    }
    while (display.nextPage());
    delay(1000);
  }
}


#ifdef _GxBitmaps200x200_H_

void drawBitmaps200x200(GxEPD2_GFX& display);

void drawBitmaps200x200(GxEPD2_GFX& display)
{
#if defined(__AVR)
  const unsigned char* bitmaps[] =
  {
    logo200x200, first200x200 //, second200x200, third200x200, fourth200x200, fifth200x200, sixth200x200, senventh200x200, eighth200x200
  };
#elif defined(_BOARD_GENERIC_STM32F103C_H_)
  const unsigned char* bitmaps[] =
  {
    logo200x200, first200x200, second200x200, third200x200, fourth200x200, fifth200x200 //, sixth200x200, senventh200x200, eighth200x200
  };
#else
  const unsigned char* bitmaps[] =
  {
    logo200x200, first200x200, second200x200, third200x200, fourth200x200, fifth200x200, sixth200x200, senventh200x200, eighth200x200
  };
#endif
  if ((display.epd2.panel == GxEPD2::GDEP015OC1) || (display.epd2.panel == GxEPD2::GDEH0154D67))
  {
    bool m = display.mirror(true);
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
      }
      while (display.nextPage());
      delay(2000);
    }
    display.mirror(m);
  }
  //else
  {
    bool mirror_y = (display.epd2.panel != GxEPD2::GDE0213B1);
    display.clearScreen(); // use default for white
    int16_t x = (int16_t(display.epd2.WIDTH) - 200) / 2;
    int16_t y = (int16_t(display.epd2.HEIGHT) - 200) / 2;
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.drawImage(bitmaps[i], x, y, 200, 200, false, mirror_y, true);
      delay(2000);
    }
  }
  bool mirror_y = (display.epd2.panel != GxEPD2::GDE0213B1);
  for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
  {
    int16_t x = -60;
    int16_t y = -60;
    for (uint16_t j = 0; j < 10; j++)
    {
      display.writeScreenBuffer(); // use default for white
      display.writeImage(bitmaps[i], x, y, 200, 200, false, mirror_y, true);
      display.refresh(true);
      if (display.epd2.hasFastPartialUpdate)
      {
        // for differential update: set previous buffer equal to current buffer in controller
        display.epd2.writeScreenBufferAgain(); // use default for white
        display.epd2.writeImageAgain(bitmaps[i], x, y, 200, 200, false, mirror_y, true);
      }
      delay(2000);
      x += 40;
      y += 40;
      if ((x >= int16_t(display.epd2.WIDTH)) || (y >= int16_t(display.epd2.HEIGHT))) break;
    }
    if (!display.epd2.hasFastPartialUpdate) break; // comment out for full show
    break; // comment out for full show
  }
  display.writeScreenBuffer(); // use default for white
  display.writeImage(bitmaps[0], int16_t(0), 0, 200, 200, false, mirror_y, true);
  display.writeImage(bitmaps[0], int16_t(int16_t(display.epd2.WIDTH) - 200), int16_t(display.epd2.HEIGHT) - 200, 200, 200, false, mirror_y, true);
  display.refresh(true);
  delay(2000);
}
#endif

#ifdef _GxBitmaps128x250_H_

void drawBitmaps128x250(GxEPD2_GFX& display);

void drawBitmaps128x250(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  const unsigned char* bitmaps[] =
  {
    Bitmap128x250_1, logo128x250, first128x250, second128x250, third128x250
  };
#else
  const unsigned char* bitmaps[] =
  {
    Bitmap128x250_1, logo128x250, first128x250, second128x250, third128x250
  };
#endif
  if (display.epd2.panel == GxEPD2::GDE0213B1)
  {
    bool m = display.mirror(true);
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
      }
      while (display.nextPage());
      delay(2000);
    }
    display.mirror(m);
  }
}
#endif

#ifdef _GxBitmaps128x296_H_

void drawBitmaps128x296(GxEPD2_GFX& display);

void drawBitmaps128x296(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  const unsigned char* bitmaps[] =
  {
    Bitmap128x296_1, logo128x296, first128x296, second128x296, third128x296
  };
#else
  const unsigned char* bitmaps[] =
  {
    Bitmap128x296_1, logo128x296 //, first128x296, second128x296, third128x296
  };
#endif
  if (display.epd2.panel == GxEPD2::GDEH029A1)
  {
    bool m = display.mirror(true);
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
      }
      while (display.nextPage());
      delay(2000);
    }
    display.mirror(m);
  }
}
#endif

#ifdef _GxBitmaps176x264_H_

void drawBitmaps176x264(GxEPD2_GFX& display);

void drawBitmaps176x264(GxEPD2_GFX& display)
{
  const unsigned char* bitmaps[] =
  {
    Bitmap176x264_1, Bitmap176x264_2
  };
  if (display.epd2.panel == GxEPD2::GDEW027W3)
  {
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif

#ifdef _GxBitmaps400x300_H_

void drawBitmaps400x300(GxEPD2_GFX& display);

void drawBitmaps400x300(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  const unsigned char* bitmaps[] =
  {
    Bitmap400x300_1, Bitmap400x300_2
  };
#else
  const unsigned char* bitmaps[] = {}; // not enough code space
#endif
  if (display.epd2.panel == GxEPD2::GDEW042T2)
  {
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif

#ifdef _GxBitmaps640x384_H_

void drawBitmaps640x384(GxEPD2_GFX& display);

void drawBitmaps640x384(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  const unsigned char* bitmaps[] =
  {
    Bitmap640x384_1, Bitmap640x384_2
  };
#else
  const unsigned char* bitmaps[] = {}; // not enough code space
#endif
  if (display.epd2.panel == GxEPD2::GDEW075T8)
  {
    for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif

struct bitmap_pair
{
  const unsigned char* black;
  const unsigned char* red;
};

#ifdef _GxBitmaps3c200x200_H_

void drawBitmaps3c200x200(GxEPD2_GFX& display);

void drawBitmaps3c200x200(GxEPD2_GFX& display)
{
  bitmap_pair bitmap_pairs[] =
  {
    //{Bitmap3c200x200_black, Bitmap3c200x200_red},
    {WS_Bitmap3c200x200_black, WS_Bitmap3c200x200_red}
  };
  if (display.epd2.panel == GxEPD2::GDEW0154Z04)
  {
    display.firstPage();
    do
    {
      display.fillScreen(GxEPD_WHITE);
      // Bitmap3c200x200_black has 2 bits per pixel
      // taken from Adafruit_GFX.cpp, modified
      int16_t byteWidth = (display.epd2.WIDTH + 7) / 8; // Bitmap scanline pad = whole byte
      uint8_t byte = 0;
      for (int16_t j = 0; j < display.epd2.HEIGHT; j++)
      {
        for (int16_t i = 0; i < display.epd2.WIDTH; i++)
        {
          if (i & 3) byte <<= 2;
          else
          {
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
            byte = pgm_read_byte(&Bitmap3c200x200_black[j * byteWidth * 2 + i / 4]);
#else
            byte = Bitmap3c200x200_black[j * byteWidth * 2 + i / 4];
#endif
          }
          if (!(byte & 0x80))
          {
            display.drawPixel(i, j, GxEPD_BLACK);
          }
        }
      }
      display.drawInvertedBitmap(0, 0, Bitmap3c200x200_red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
    }
    while (display.nextPage());
    delay(2000);
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmap_pairs[i].black, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
        display.drawInvertedBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
  if (display.epd2.hasColor)
  {
    display.clearScreen(); // use default for white
    int16_t x = (int16_t(display.epd2.WIDTH) - 200) / 2;
    int16_t y = (int16_t(display.epd2.HEIGHT) - 200) / 2;
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      display.drawImage(bitmap_pairs[i].black, bitmap_pairs[i].red, x, y, 200, 200, false, false, true);
      delay(2000);
    }
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      int16_t x = -60;
      int16_t y = -60;
      for (uint16_t j = 0; j < 10; j++)
      {
        display.writeScreenBuffer(); // use default for white
        display.writeImage(bitmap_pairs[i].black, bitmap_pairs[i].red, x, y, 200, 200, false, false, true);
        display.refresh();
        delay(2000);
        x += 40;
        y += 40;
        if ((x >= int16_t(display.epd2.WIDTH)) || (y >= int16_t(display.epd2.HEIGHT))) break;
      }
    }
    display.writeScreenBuffer(); // use default for white
    display.writeImage(bitmap_pairs[0].black, bitmap_pairs[0].red, 0, 0, 200, 200, false, false, true);
    display.writeImage(bitmap_pairs[0].black, bitmap_pairs[0].red, int16_t(display.epd2.WIDTH) - 200, int16_t(display.epd2.HEIGHT) - 200, 200, 200, false, false, true);
    display.refresh();
    delay(2000);
  }
}
#endif

#ifdef _GxBitmaps3c104x212_H_

void drawBitmaps3c104x212(GxEPD2_GFX& display);

void drawBitmaps3c104x212(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  bitmap_pair bitmap_pairs[] =
  {
    {Bitmap3c104x212_1_black, Bitmap3c104x212_1_red},
    {Bitmap3c104x212_2_black, Bitmap3c104x212_2_red},
    {WS_Bitmap3c104x212_black, WS_Bitmap3c104x212_red}
  };
#else
  bitmap_pair bitmap_pairs[] =
  {
    {Bitmap3c104x212_1_black, Bitmap3c104x212_1_red},
    //{Bitmap3c104x212_2_black, Bitmap3c104x212_2_red},
    {WS_Bitmap3c104x212_black, WS_Bitmap3c104x212_red}
  };
#endif
  if (display.epd2.panel == GxEPD2::GDEW0213Z16)
  {
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmap_pairs[i].black, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
        if (bitmap_pairs[i].red == WS_Bitmap3c104x212_red)
        {
          display.drawInvertedBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
        }
        else display.drawBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif

#ifdef _GxBitmaps3c128x296_H_

void drawBitmaps3c128x296(GxEPD2_GFX& display);

void drawBitmaps3c128x296(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  bitmap_pair bitmap_pairs[] =
  {
    {Bitmap3c128x296_1_black, Bitmap3c128x296_1_red},
    {Bitmap3c128x296_2_black, Bitmap3c128x296_2_red},
    {WS_Bitmap3c128x296_black, WS_Bitmap3c128x296_red}
  };
#else
  bitmap_pair bitmap_pairs[] =
  {
    //{Bitmap3c128x296_1_black, Bitmap3c128x296_1_red},
    //{Bitmap3c128x296_2_black, Bitmap3c128x296_2_red},
    {WS_Bitmap3c128x296_black, WS_Bitmap3c128x296_red}
  };
#endif
  if (display.epd2.panel == GxEPD2::GDEW029Z10)
  {
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmap_pairs[i].black, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
        if (bitmap_pairs[i].red == WS_Bitmap3c128x296_red)
        {
          display.drawInvertedBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
        }
        else display.drawBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif

#ifdef _GxBitmaps3c176x264_H_

void drawBitmaps3c176x264(GxEPD2_GFX& display);

void drawBitmaps3c176x264(GxEPD2_GFX& display)
{
  bitmap_pair bitmap_pairs[] =
  {
    {Bitmap3c176x264_black, Bitmap3c176x264_red}
  };
  if (display.epd2.panel == GxEPD2::GDEW027C44)
  {
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawBitmap(0, 0, bitmap_pairs[i].black, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
        display.drawBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif

#ifdef _GxBitmaps3c400x300_H_

void drawBitmaps3c400x300(GxEPD2_GFX& display);

void drawBitmaps3c400x300(GxEPD2_GFX& display)
{
#if !defined(__AVR)
  bitmap_pair bitmap_pairs[] =
  {
    {Bitmap3c400x300_1_black, Bitmap3c400x300_1_red},
    {Bitmap3c400x300_2_black, Bitmap3c400x300_2_red},
    {WS_Bitmap3c400x300_black, WS_Bitmap3c400x300_red}
  };
#else
  bitmap_pair bitmap_pairs[] = {}; // not enough code space
#endif
  if (display.epd2.panel == GxEPD2::GDEW042Z15)
  {
    for (uint16_t i = 0; i < sizeof(bitmap_pairs) / sizeof(bitmap_pair); i++)
    {
      display.firstPage();
      do
      {
        display.fillScreen(GxEPD_WHITE);
        display.drawInvertedBitmap(0, 0, bitmap_pairs[i].black, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
        display.drawInvertedBitmap(0, 0, bitmap_pairs[i].red, display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_RED);
      }
      while (display.nextPage());
      delay(2000);
    }
  }
}
#endif


void drawBitmaps(GxEPD2_GFX& display)
{
  display.setFullWindow();
  display.setRotation(0);
#ifdef _GxBitmaps128x250_H_
  drawBitmaps128x250(display);
#endif
#ifdef _GxBitmaps128x296_H_
  drawBitmaps128x296(display);
#endif
#ifdef _GxBitmaps176x264_H_
  drawBitmaps176x264(display);
#endif
#ifdef _GxBitmaps400x300_H_
  drawBitmaps400x300(display);
#endif
#ifdef _GxBitmaps640x384_H_
  drawBitmaps640x384(display);
#endif
  // 3-color
#ifdef _GxBitmaps3c104x212_H_
  drawBitmaps3c104x212(display);
#endif
#ifdef _GxBitmaps3c128x296_H_
  drawBitmaps3c128x296(display);
#endif
#ifdef _GxBitmaps3c176x264_H_
  drawBitmaps3c176x264(display);
#endif
#ifdef _GxBitmaps3c400x300_H_
  drawBitmaps3c400x300(display);
#endif
  // show these after the specific bitmaps
#ifdef _GxBitmaps200x200_H_
  drawBitmaps200x200(display);
#endif
  // 3-color
#ifdef _GxBitmaps3c200x200_H_
  drawBitmaps3c200x200(display);
#endif
}
",16288,True,2589.144110050437,median
"#include ""HaskinoRuntime.h""

void haskinoMain();
#define HASKINOMAIN_STACK_SIZE 920
byte haskinoMainTcb[sizeof(TCB) + HASKINOMAIN_STACK_SIZE];

// ******** Start of Instrumentation            
#define TEST_COUNT 1000
#define TEST_CMD  0x20
static uint8_t cmdChar;
static uint32_t start;
static uint32_t end;
static uint32_t cmdCount = 0;
static uint32_t charCount;

void sendStringf(const char *fmt, ...);

// ******** End of Instrumentation            

void setup()
    {
    haskinoMemInit();
    createTask(255, haskinoMainTcb, HASKINOMAIN_STACK_SIZE, haskinoMain);
    scheduleTask(255, 0);
    startScheduler();
    }

void loop()
    {
    }

uint8_t ref0;

void haskinoMain()
    {
    int32_t bind0;

    ref0 = 0;
    serialBegin(0,115200);
    bind0 = 0;
    int32_t bind3;
    uint8_t * bind4 = NULL;
    uint8_t * bind5 = NULL;
    while (1)
        {
        ref0 = 0;
        listAssign(&bind4, (uint8_t * ) (const byte[]) {255, 0});
        bind3 = 0;
        int32_t bind6;
        uint8_t bind8;
        // ******** Start of Instrumentation
        charCount = 0;
        // ******** End of Instrumentation
        while (1)
            {
            bind6 = 0;
            uint32_t bind9;
            while (1)
                {
                bind9 = serialAvailable(0);
                if ((0 < bind9))
                    {
                    int32_t bind10;

                    bind10 = serialRead(0);
                    bind8 = ((uint8_t) ((int32_t) bind10));
                    break;
                    }
                else
                    {
                    bind6 = 0;
                    }
                }
            if ((bind8 == 125))
                {
                int32_t bind11;
                uint8_t bind13;
                uint8_t bind16;

                bind11 = 0;
                uint32_t bind14;
                while (1)
                    {
                    bind14 = serialAvailable(0);
                    if ((0 < bind14))
                        {
                        int32_t bind15;

                        bind15 = serialRead(0);
                        bind13 = ((uint8_t) ((int32_t) bind15));
                        break;
                        }
                    else
                        {
                        bind11 = 0;
                        }
                    }
                bind16 = ref0;
                ref0 = ((bind16 + bind13) ^ 32);
                }
            else
                {
                if ((bind8 == 126))
                    {
                    uint8_t bind17;
                    uint8_t * bind18 = NULL;

                    bind17 = ref0;
                    if ((((uint8_t) (bind17 - list8Elem(bind4,(list8Len(bind4) - 1)))) == ((uint8_t) list8Elem(bind4,(list8Len(bind4) - 1)))))
                        {
                        listAssign(&bind18, list8Slice(bind4,0,(list8Len(bind4) - 1)));
                        }
                    else
                        {
                        listAssign(&bind18, (uint8_t * ) (const byte[]) {255, 0});
                        }
                    listAssign(&bind5, bind18);
                    listRelease(&bind18);
                    break;
                    }
                else
                    {
                    uint8_t bind19;

                    // ******** Start of Instrumentation
                    if (charCount == 0 && bind8 == TEST_CMD && cmdCount == 0)
                        {
                        cmdChar = bind8;
                        start = millis();
                        }
                    if (charCount == 0 && bind8 == TEST_CMD)
                        {
                        cmdCount++;
                        }
                    charCount++;
                    // ******** End of Instrumentation
                    bind19 = ref0;
                    ref0 = (bind19 + bind8);
                    bind3 = 0;
                    listAssign(&bind4, list8Apnd(bind4,list8Cons(bind8,(uint8_t * ) (const byte[]) {255, 0})));
                    }
                }
            }
        if ((list8Len(bind5) == 0))
            {
            }
        else
            {
            if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 16))
                {
                if ((((uint8_t) list8Elem(bind5,0)) == 16))
                    {
                    soft_restart();
                    }
                else
                    {
                    if ((((uint8_t) list8Elem(bind5,0)) == 17))
                        {
                        if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                            {
                            pinMode(list8Elem(bind5,(1 + 2)),(((uint8_t) list8Elem(bind5,(1 + 5))) == 0) ? INPUT : (((uint8_t) list8Elem(bind5,(1 + 5))) == 1) ? OUTPUT : (((uint8_t) list8Elem(bind5,(1 + 5))) == 2) ? INPUT_PULLUP : INPUT);
                            }
                        else
                            {
                            }
                        }
                    else
                        {
                        if ((((uint8_t) list8Elem(bind5,0)) == 18))
                            {
                            if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 4) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                {
                                int32_t bind27;
                                uint8_t * bind28 = NULL;

                                delayMilliseconds(((((((uint32_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 24) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 5)))) << 16)) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 4)))) << 8)) | ((uint32_t) ((int32_t) list8Elem(bind5,(1 + 3))))));
                                listAssign(&bind28, list8Cons(0,list8Cons(24,(uint8_t * ) (const byte[]) {255, 0})));
                                bind27 = 0;
                                while (1)
                                    {
                                    if (((((uint8_t) list8Elem(bind28,1)) == 126) || (((uint8_t) list8Elem(bind28,1)) == 125)))
                                        {
                                        serialWrite(0,125);
                                        serialWrite(0,(list8Elem(bind28,1) ^ 32));
                                        }
                                    else
                                        {
                                        serialWrite(0,list8Elem(bind28,1));
                                        }
                                    if ((list8Len(bind28) == 2))
                                        {
                                        if (((((uint8_t) (list8Elem(bind28,0) + list8Elem(bind28,1))) == 126) || (((uint8_t) (list8Elem(bind28,0) + list8Elem(bind28,1))) == 125)))
                                            {
                                            serialWrite(0,125);
                                            serialWrite(0,((list8Elem(bind28,0) + list8Elem(bind28,1)) ^ 32));
                                            }
                                        else
                                            {
                                            serialWrite(0,(list8Elem(bind28,0) + list8Elem(bind28,1)));
                                            }
                                        break;
                                        }
                                    else
                                        {
                                        bind27 = 0;
                                        listAssign(&bind28, list8Cons((list8Elem(bind28,0) + list8Elem(bind28,1)),list8Slice(bind28,2,0)));
                                        }
                                    }
                                serialWrite(0,126);
                                listRelease(&bind28);
                                }
                            else
                                {
                                }
                            }
                        else
                            {
                            if ((((uint8_t) list8Elem(bind5,0)) == 19))
                                {
                                if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 4) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                    {
                                    int32_t bind34;
                                    uint8_t * bind35 = NULL;

                                    delayMicroseconds(((((((uint32_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 24) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 5)))) << 16)) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 4)))) << 8)) | ((uint32_t) ((int32_t) list8Elem(bind5,(1 + 3))))));
                                    listAssign(&bind35, list8Cons(0,list8Cons(24,(uint8_t * ) (const byte[]) {255, 0})));
                                    bind34 = 0;
                                    while (1)
                                        {
                                        if (((((uint8_t) list8Elem(bind35,1)) == 126) || (((uint8_t) list8Elem(bind35,1)) == 125)))
                                            {
                                            serialWrite(0,125);
                                            serialWrite(0,(list8Elem(bind35,1) ^ 32));
                                            }
                                        else
                                            {
                                            serialWrite(0,list8Elem(bind35,1));
                                            }
                                        if ((list8Len(bind35) == 2))
                                            {
                                            if (((((uint8_t) (list8Elem(bind35,0) + list8Elem(bind35,1))) == 126) || (((uint8_t) (list8Elem(bind35,0) + list8Elem(bind35,1))) == 125)))
                                                {
                                                serialWrite(0,125);
                                                serialWrite(0,((list8Elem(bind35,0) + list8Elem(bind35,1)) ^ 32));
                                                }
                                            else
                                                {
                                                serialWrite(0,(list8Elem(bind35,0) + list8Elem(bind35,1)));
                                                }
                                            break;
                                            }
                                        else
                                            {
                                            bind34 = 0;
                                            listAssign(&bind35, list8Cons((list8Elem(bind35,0) + list8Elem(bind35,1)),list8Slice(bind35,2,0)));
                                            }
                                        }
                                    serialWrite(0,126);
                                    listRelease(&bind35);
                                    }
                                else
                                    {
                                    }
                                }
                            else
                                {
                                }
                            }
                        }
                    }
                }
            else
                {
                if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 32))
                    {
                    if ((((uint8_t) list8Elem(bind5,0)) == 32))
                        {
                        uint16_t bind41;
                        int32_t bind42;
                        uint8_t * bind43 = NULL;

                        bind41 = queryFirmware();
                        listAssign(&bind43, list8Cons(0,list8Cons(40,list8Cons(((uint8_t) ((int32_t) (bind41 & 255))),list8Cons(((uint8_t) ((int32_t) (bind41 >> 8))),(uint8_t * ) (const byte[]) {255, 0})))));
                        bind42 = 0;
                        while (1)
                            {
                            if (((((uint8_t) list8Elem(bind43,1)) == 126) || (((uint8_t) list8Elem(bind43,1)) == 125)))
                                {
                                serialWrite(0,125);
                                serialWrite(0,(list8Elem(bind43,1) ^ 32));
                                }
                            else
                                {
                                serialWrite(0,list8Elem(bind43,1));
                                }
                            if ((list8Len(bind43) == 2))
                                {
                                if (((((uint8_t) (list8Elem(bind43,0) + list8Elem(bind43,1))) == 126) || (((uint8_t) (list8Elem(bind43,0) + list8Elem(bind43,1))) == 125)))
                                    {
                                    serialWrite(0,125);
                                    serialWrite(0,((list8Elem(bind43,0) + list8Elem(bind43,1)) ^ 32));
                                    }
                                else
                                    {
                                    serialWrite(0,(list8Elem(bind43,0) + list8Elem(bind43,1)));
                                    }
                                break;
                                }
                            else
                                {
                                bind42 = 0;
                                listAssign(&bind43, list8Cons((list8Elem(bind43,0) + list8Elem(bind43,1)),list8Slice(bind43,2,0)));
                                }
                            }
                        serialWrite(0,126);
                        listRelease(&bind43);
                        }
                    else
                        {
                        if ((((uint8_t) list8Elem(bind5,0)) == 33))
                            {
                            uint8_t bind48;
                            int32_t bind49;
                            uint8_t * bind50 = NULL;

                            bind48 = queryProcessor();
                            listAssign(&bind50, list8Cons(0,list8Cons(41,list8Cons(bind48,(uint8_t * ) (const byte[]) {255, 0}))));
                            bind49 = 0;
                            while (1)
                                {
                                if (((((uint8_t) list8Elem(bind50,1)) == 126) || (((uint8_t) list8Elem(bind50,1)) == 125)))
                                    {
                                    serialWrite(0,125);
                                    serialWrite(0,(list8Elem(bind50,1) ^ 32));
                                    }
                                else
                                    {
                                    serialWrite(0,list8Elem(bind50,1));
                                    }
                                if ((list8Len(bind50) == 2))
                                    {
                                    if (((((uint8_t) (list8Elem(bind50,0) + list8Elem(bind50,1))) == 126) || (((uint8_t) (list8Elem(bind50,0) + list8Elem(bind50,1))) == 125)))
                                        {
                                        serialWrite(0,125);
                                        serialWrite(0,((list8Elem(bind50,0) + list8Elem(bind50,1)) ^ 32));
                                        }
                                    else
                                        {
                                        serialWrite(0,(list8Elem(bind50,0) + list8Elem(bind50,1)));
                                        }
                                    break;
                                    }
                                else
                                    {
                                    bind49 = 0;
                                    listAssign(&bind50, list8Cons((list8Elem(bind50,0) + list8Elem(bind50,1)),list8Slice(bind50,2,0)));
                                    }
                                }
                            serialWrite(0,126);
                            listRelease(&bind50);
                            }
                        else
                            {
                            if ((((uint8_t) list8Elem(bind5,0)) == 34))
                                {
                                uint32_t bind55;
                                int32_t bind56;
                                uint8_t * bind57 = NULL;

                                bind55 = micros();
                                listAssign(&bind57, list8Cons(0,list8Cons(42,list8Cons(4,list8Cons(0,list8Cons(((uint8_t) ((int32_t) (bind55 & 255))),list8Cons(((uint8_t) ((int32_t) (bind55 >> 8))),list8Cons(((uint8_t) ((int32_t) (bind55 >> 16))),list8Cons(((uint8_t) ((int32_t) (bind55 >> 24))),(uint8_t * ) (const byte[]) {255, 0})))))))));
                                bind56 = 0;
                                while (1)
                                    {
                                    if (((((uint8_t) list8Elem(bind57,1)) == 126) || (((uint8_t) list8Elem(bind57,1)) == 125)))
                                        {
                                        serialWrite(0,125);
                                        serialWrite(0,(list8Elem(bind57,1) ^ 32));
                                        }
                                    else
                                        {
                                        serialWrite(0,list8Elem(bind57,1));
                                        }
                                    if ((list8Len(bind57) == 2))
                                        {
                                        if (((((uint8_t) (list8Elem(bind57,0) + list8Elem(bind57,1))) == 126) || (((uint8_t) (list8Elem(bind57,0) + list8Elem(bind57,1))) == 125)))
                                            {
                                            serialWrite(0,125);
                                            serialWrite(0,((list8Elem(bind57,0) + list8Elem(bind57,1)) ^ 32));
                                            }
                                        else
                                            {
                                            serialWrite(0,(list8Elem(bind57,0) + list8Elem(bind57,1)));
                                            }
                                        break;
                                        }
                                    else
                                        {
                                        bind56 = 0;
                                        listAssign(&bind57, list8Cons((list8Elem(bind57,0) + list8Elem(bind57,1)),list8Slice(bind57,2,0)));
                                        }
                                    }
                                serialWrite(0,126);
                                listRelease(&bind57);
                                }
                            else
                                {
                                if ((((uint8_t) list8Elem(bind5,0)) == 35))
                                    {
                                    uint32_t bind62;
                                    int32_t bind63;
                                    uint8_t * bind64 = NULL;

                                    bind62 = millis();
                                    listAssign(&bind64, list8Cons(0,list8Cons(43,list8Cons(4,list8Cons(0,list8Cons(((uint8_t) ((int32_t) (bind62 & 255))),list8Cons(((uint8_t) ((int32_t) (bind62 >> 8))),list8Cons(((uint8_t) ((int32_t) (bind62 >> 16))),list8Cons(((uint8_t) ((int32_t) (bind62 >> 24))),(uint8_t * ) (const byte[]) {255, 0})))))))));
                                    bind63 = 0;
                                    while (1)
                                        {
                                        if (((((uint8_t) list8Elem(bind64,1)) == 126) || (((uint8_t) list8Elem(bind64,1)) == 125)))
                                            {
                                            serialWrite(0,125);
                                            serialWrite(0,(list8Elem(bind64,1) ^ 32));
                                            }
                                        else
                                            {
                                            serialWrite(0,list8Elem(bind64,1));
                                            }
                                        if ((list8Len(bind64) == 2))
                                            {
                                            if (((((uint8_t) (list8Elem(bind64,0) + list8Elem(bind64,1))) == 126) || (((uint8_t) (list8Elem(bind64,0) + list8Elem(bind64,1))) == 125)))
                                                {
                                                serialWrite(0,125);
                                                serialWrite(0,((list8Elem(bind64,0) + list8Elem(bind64,1)) ^ 32));
                                                }
                                            else
                                                {
                                                serialWrite(0,(list8Elem(bind64,0) + list8Elem(bind64,1)));
                                                }
                                            break;
                                            }
                                        else
                                            {
                                            bind63 = 0;
                                            listAssign(&bind64, list8Cons((list8Elem(bind64,0) + list8Elem(bind64,1)),list8Slice(bind64,2,0)));
                                            }
                                        }
                                    serialWrite(0,126);
                                    listRelease(&bind64);
                                    }
                                else
                                    {
                                    if ((((uint8_t) list8Elem(bind5,0)) == 0))
                                        {
                                        int32_t bind69;
                                        uint8_t * bind70 = NULL;

                                        listAssign(&bind70, list8Cons(0,list8Cons(44,list8Slice(bind5,1,0))));
                                        bind69 = 0;
                                        while (1)
                                            {
                                            if (((((uint8_t) list8Elem(bind70,1)) == 126) || (((uint8_t) list8Elem(bind70,1)) == 125)))
                                                {
                                                serialWrite(0,125);
                                                serialWrite(0,(list8Elem(bind70,1) ^ 32));
                                                }
                                            else
                                                {
                                                serialWrite(0,list8Elem(bind70,1));
                                                }
                                            if ((list8Len(bind70) == 2))
                                                {
                                                if (((((uint8_t) (list8Elem(bind70,0) + list8Elem(bind70,1))) == 126) || (((uint8_t) (list8Elem(bind70,0) + list8Elem(bind70,1))) == 125)))
                                                    {
                                                    serialWrite(0,125);
                                                    serialWrite(0,((list8Elem(bind70,0) + list8Elem(bind70,1)) ^ 32));
                                                    }
                                                else
                                                    {
                                                    serialWrite(0,(list8Elem(bind70,0) + list8Elem(bind70,1)));
                                                    }
                                                break;
                                                }
                                            else
                                                {
                                                bind69 = 0;
                                                listAssign(&bind70, list8Cons((list8Elem(bind70,0) + list8Elem(bind70,1)),list8Slice(bind70,2,0)));
                                                }
                                            }
                                        serialWrite(0,126);
                                        listRelease(&bind70);
                                        }
                                    else
                                        {
                                        }
                                    }
                                }
                            }
                        }
                    }
                else
                    {
                    if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 48))
                        {
                        if ((((uint8_t) list8Elem(bind5,0)) == 48))
                            {
                            if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                {
                                bool bind77;
                                int32_t bind78;
                                uint8_t * bind79 = NULL;

                                bind77 = digitalRead(list8Elem(bind5,(1 + 3)));
                                listAssign(&bind79, list8Cons(0,list8Cons(56,list8Cons(1,list8Cons(0,list8Cons(bind77 ? 1 : 0,(uint8_t * ) (const byte[]) {255, 0}))))));
                                bind78 = 0;
                                while (1)
                                    {
                                    if (((((uint8_t) list8Elem(bind79,1)) == 126) || (((uint8_t) list8Elem(bind79,1)) == 125)))
                                        {
                                        serialWrite(0,125);
                                        serialWrite(0,(list8Elem(bind79,1) ^ 32));
                                        }
                                    else
                                        {
                                        serialWrite(0,list8Elem(bind79,1));
                                        }
                                    if ((list8Len(bind79) == 2))
                                        {
                                        if (((((uint8_t) (list8Elem(bind79,0) + list8Elem(bind79,1))) == 126) || (((uint8_t) (list8Elem(bind79,0) + list8Elem(bind79,1))) == 125)))
                                            {
                                            serialWrite(0,125);
                                            serialWrite(0,((list8Elem(bind79,0) + list8Elem(bind79,1)) ^ 32));
                                            }
                                        else
                                            {
                                            serialWrite(0,(list8Elem(bind79,0) + list8Elem(bind79,1)));
                                            }
                                        break;
                                        }
                                    else
                                        {
                                        bind78 = 0;
                                        listAssign(&bind79, list8Cons((list8Elem(bind79,0) + list8Elem(bind79,1)),list8Slice(bind79,2,0)));
                                        }
                                    }
                                serialWrite(0,126);
                                listRelease(&bind79);
                                }
                            else
                                {
                                }
                            }
                        else
                            {
                            if ((((uint8_t) list8Elem(bind5,0)) == 49))
                                {
                                if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 1) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                    {
                                    digitalWrite(list8Elem(bind5,(1 + 2)),(((uint8_t) list8Elem(bind5,(1 + 5))) == 0) ? 0 : 1);
                                    }
                                else
                                    {
                                    }
                                }
                            else
                                {
                                if ((((uint8_t) list8Elem(bind5,0)) == 50))
                                    {
                                    if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 2))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 5))) == 0)))))
                                        {
                                        uint8_t bind87;
                                        int32_t bind88;
                                        uint8_t * bind89 = NULL;

                                        bind87 = digitalPortRead(list8Elem(bind5,(1 + 3)),list8Elem(bind5,(1 + 6)));
                                        listAssign(&bind89, list8Cons(0,list8Cons(57,list8Cons(2,list8Cons(0,list8Cons(bind87,(uint8_t * ) (const byte[]) {255, 0}))))));
                                        bind88 = 0;
                                        while (1)
                                            {
                                            if (((((uint8_t) list8Elem(bind89,1)) == 126) || (((uint8_t) list8Elem(bind89,1)) == 125)))
                                                {
                                                serialWrite(0,125);
                                                serialWrite(0,(list8Elem(bind89,1) ^ 32));
                                                }
                                            else
                                                {
                                                serialWrite(0,list8Elem(bind89,1));
                                                }
                                            if ((list8Len(bind89) == 2))
                                                {
                                                if (((((uint8_t) (list8Elem(bind89,0) + list8Elem(bind89,1))) == 126) || (((uint8_t) (list8Elem(bind89,0) + list8Elem(bind89,1))) == 125)))
                                                    {
                                                    serialWrite(0,125);
                                                    serialWrite(0,((list8Elem(bind89,0) + list8Elem(bind89,1)) ^ 32));
                                                    }
                                                else
                                                    {
                                                    serialWrite(0,(list8Elem(bind89,0) + list8Elem(bind89,1)));
                                                    }
                                                break;
                                                }
                                            else
                                                {
                                                bind88 = 0;
                                                listAssign(&bind89, list8Cons((list8Elem(bind89,0) + list8Elem(bind89,1)),list8Slice(bind89,2,0)));
                                                }
                                            }
                                        serialWrite(0,126);
                                        listRelease(&bind89);
                                        }
                                    else
                                        {
                                        }
                                    }
                                else
                                    {
                                    if ((((uint8_t) list8Elem(bind5,0)) == 51))
                                        {
                                        if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 6))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 7))) == 0)))))))
                                            {
                                            digitalPortWrite(list8Elem(bind5,(1 + 2)),list8Elem(bind5,(1 + 5)),list8Elem(bind5,(1 + 8)));
                                            }
                                        else
                                            {
                                            }
                                        }
                                    else
                                        {
                                        }
                                    }
                                }
                            }
                        }
                    else
                        {
                        if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 64))
                            {
                            if ((((uint8_t) list8Elem(bind5,0)) == 64))
                                {
                                if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                    {
                                    uint16_t bind98;
                                    int32_t bind99;
                                    uint8_t * bind100 = NULL;

                                    bind98 = analogRead(list8Elem(bind5,(1 + 3)));
                                    listAssign(&bind100, list8Cons(0,list8Cons(72,list8Cons(3,list8Cons(0,list8Cons(((uint8_t) ((int32_t) (bind98 & 255))),list8Cons(((uint8_t) ((int32_t) (bind98 >> 8))),(uint8_t * ) (const byte[]) {255, 0})))))));
                                    bind99 = 0;
                                    while (1)
                                        {
                                        if (((((uint8_t) list8Elem(bind100,1)) == 126) || (((uint8_t) list8Elem(bind100,1)) == 125)))
                                            {
                                            serialWrite(0,125);
                                            serialWrite(0,(list8Elem(bind100,1) ^ 32));
                                            }
                                        else
                                            {
                                            serialWrite(0,list8Elem(bind100,1));
                                            }
                                        if ((list8Len(bind100) == 2))
                                            {
                                            if (((((uint8_t) (list8Elem(bind100,0) + list8Elem(bind100,1))) == 126) || (((uint8_t) (list8Elem(bind100,0) + list8Elem(bind100,1))) == 125)))
                                                {
                                                serialWrite(0,125);
                                                serialWrite(0,((list8Elem(bind100,0) + list8Elem(bind100,1)) ^ 32));
                                                }
                                            else
                                                {
                                                serialWrite(0,(list8Elem(bind100,0) + list8Elem(bind100,1)));
                                                }
                                            break;
                                            }
                                        else
                                            {
                                            bind99 = 0;
                                            listAssign(&bind100, list8Cons((list8Elem(bind100,0) + list8Elem(bind100,1)),list8Slice(bind100,2,0)));
                                            }
                                        }
                                    serialWrite(0,126);
                                    listRelease(&bind100);
                                    }
                                else
                                    {
                                    }
                                }
                            else
                                {
                                if ((((uint8_t) list8Elem(bind5,0)) == 65))
                                    {
                                    if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 3) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                        {
                                        analogWrite(list8Elem(bind5,(1 + 2)),((((uint16_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 8) | ((uint16_t) ((int32_t) list8Elem(bind5,(1 + 5))))));
                                        }
                                    else
                                        {
                                        }
                                    }
                                else
                                    {
                                    if ((((uint8_t) list8Elem(bind5,0)) == 66))
                                        {
                                        if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 3) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 7))) == 4) && (((uint8_t) list8Elem(bind5,(1 + 8))) == 0)))))))
                                            {
                                            if ((((((((uint32_t) ((int32_t) list8Elem(bind5,(1 + 11)))) << 24) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 10)))) << 16)) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 9)))) << 8)) | ((uint32_t) ((int32_t) list8Elem(bind5,(1 + 8))))) == 0))
                                                {
                                                tone(list8Elem(bind5,(1 + 2)),((((uint16_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 8) | ((uint16_t) ((int32_t) list8Elem(bind5,(1 + 5))))),0);
                                                }
                                            else
                                                {
                                                tone(list8Elem(bind5,(1 + 2)),((((uint16_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 8) | ((uint16_t) ((int32_t) list8Elem(bind5,(1 + 5))))),((((((uint32_t) ((int32_t) list8Elem(bind5,(1 + 11)))) << 24) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 10)))) << 16)) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 9)))) << 8)) | ((uint32_t) ((int32_t) list8Elem(bind5,(1 + 8))))));
                                                }
                                            }
                                        else
                                            {
                                            }
                                        }
                                    else
                                        {
                                        if ((((uint8_t) list8Elem(bind5,0)) == 67))
                                            {
                                            if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 1))) == 0)))
                                                {
                                                noTone(list8Elem(bind5,(1 + 2)));
                                                }
                                            else
                                                {
                                                }
                                            }
                                        else
                                            {
                                            }
                                        }
                                    }
                                }
                            }
                        else
                            {
                            if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 80))
                                {
                                if ((((uint8_t) list8Elem(bind5,0)) == 80))
                                    {
                                    i2cConfig();
                                    }
                                else
                                    {
                                    if ((((uint8_t) list8Elem(bind5,0)) == 81))
                                        {
                                        if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 2))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 5))) == 0)))))
                                            {
                                            uint8_t * bind115 = NULL;
                                            int32_t bind116;
                                            uint8_t * bind117 = NULL;

                                            listAssign(&bind115, i2cRead(list8Elem(bind5,(1 + 3)),list8Elem(bind5,(1 + 6))));
                                            listAssign(&bind117, list8Cons(0,list8Cons(88,list8Cons(8,list8Cons(0,list8Cons(((uint8_t) list8Len(bind115)),bind115))))));
                                            bind116 = 0;
                                            while (1)
                                                {
                                                if (((((uint8_t) list8Elem(bind117,1)) == 126) || (((uint8_t) list8Elem(bind117,1)) == 125)))
                                                    {
                                                    serialWrite(0,125);
                                                    serialWrite(0,(list8Elem(bind117,1) ^ 32));
                                                    }
                                                else
                                                    {
                                                    serialWrite(0,list8Elem(bind117,1));
                                                    }
                                                if ((list8Len(bind117) == 2))
                                                    {
                                                    if (((((uint8_t) (list8Elem(bind117,0) + list8Elem(bind117,1))) == 126) || (((uint8_t) (list8Elem(bind117,0) + list8Elem(bind117,1))) == 125)))
                                                        {
                                                        serialWrite(0,125);
                                                        serialWrite(0,((list8Elem(bind117,0) + list8Elem(bind117,1)) ^ 32));
                                                        }
                                                    else
                                                        {
                                                        serialWrite(0,(list8Elem(bind117,0) + list8Elem(bind117,1)));
                                                        }
                                                    break;
                                                    }
                                                else
                                                    {
                                                    bind116 = 0;
                                                    listAssign(&bind117, list8Cons((list8Elem(bind117,0) + list8Elem(bind117,1)),list8Slice(bind117,2,0)));
                                                    }
                                                }
                                            serialWrite(0,126);
                                            listRelease(&bind115);
                                            listRelease(&bind117);
                                            }
                                        else
                                            {
                                            }
                                        }
                                    else
                                        {
                                        if ((((uint8_t) list8Elem(bind5,0)) == 82))
                                            {
                                            if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 8) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 0) && ((list8Len(bind5) - 1) == (((int32_t) list8Elem(bind5,(1 + 5))) + 6)))))))
                                                {
                                                i2cWrite(list8Elem(bind5,(1 + 2)),list8Slice(list8Slice(bind5,1,0),6,0));
                                                }
                                            else
                                                {
                                                }
                                            }
                                        else
                                            {
                                            }
                                        }
                                    }
                                }
                            else
                                {
                                if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 224))
                                    {
                                    if ((((uint8_t) list8Elem(bind5,0)) == 224))
                                        {
                                        if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 4) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                            {
                                            serialBegin(list8Elem(bind5,(1 + 2)),((((((uint32_t) ((int32_t) list8Elem(bind5,(1 + 8)))) << 24) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 7)))) << 16)) | (((uint32_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 8)) | ((uint32_t) ((int32_t) list8Elem(bind5,(1 + 5))))));
                                            }
                                        else
                                            {
                                            }
                                        }
                                    else
                                        {
                                        if ((((uint8_t) list8Elem(bind5,0)) == 225))
                                            {
                                            if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 1))) == 0)))
                                                {
                                                serialEnd(list8Elem(bind5,(1 + 2)));
                                                }
                                            else
                                                {
                                                }
                                            }
                                        else
                                            {
                                            if ((((uint8_t) list8Elem(bind5,0)) == 227))
                                                {
                                                if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                                    {
                                                    int32_t bind130;
                                                    int32_t bind131;
                                                    uint8_t * bind132 = NULL;

                                                    bind130 = serialRead(list8Elem(bind5,(1 + 3)));
                                                    listAssign(&bind132, list8Cons(0,list8Cons(233,list8Cons(4,list8Cons(0,list8Cons(((uint8_t) ((int32_t) (bind130 & 255))),list8Cons(((uint8_t) ((int32_t) (bind130 >> 8))),list8Cons(((uint8_t) ((int32_t) (bind130 >> 16))),list8Cons(((uint8_t) ((int32_t) (bind130 >> 24))),(uint8_t * ) (const byte[]) {255, 0})))))))));
                                                    bind131 = 0;
                                                    while (1)
                                                        {
                                                        if (((((uint8_t) list8Elem(bind132,1)) == 126) || (((uint8_t) list8Elem(bind132,1)) == 125)))
                                                            {
                                                            serialWrite(0,125);
                                                            serialWrite(0,(list8Elem(bind132,1) ^ 32));
                                                            }
                                                        else
                                                            {
                                                            serialWrite(0,list8Elem(bind132,1));
                                                            }
                                                        if ((list8Len(bind132) == 2))
                                                            {
                                                            if (((((uint8_t) (list8Elem(bind132,0) + list8Elem(bind132,1))) == 126) || (((uint8_t) (list8Elem(bind132,0) + list8Elem(bind132,1))) == 125)))
                                                                {
                                                                serialWrite(0,125);
                                                                serialWrite(0,((list8Elem(bind132,0) + list8Elem(bind132,1)) ^ 32));
                                                                }
                                                            else
                                                                {
                                                                serialWrite(0,(list8Elem(bind132,0) + list8Elem(bind132,1)));
                                                                }
                                                            break;
                                                            }
                                                        else
                                                            {
                                                            bind131 = 0;
                                                            listAssign(&bind132, list8Cons((list8Elem(bind132,0) + list8Elem(bind132,1)),list8Slice(bind132,2,0)));
                                                            }
                                                        }
                                                    serialWrite(0,126);
                                                    listRelease(&bind132);
                                                    }
                                                else
                                                    {
                                                    }
                                                }
                                            else
                                                {
                                                if ((((uint8_t) list8Elem(bind5,0)) == 228))
                                                    {
                                                    if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                                        {
                                                        uint8_t * bind138 = NULL;
                                                        int32_t bind139;
                                                        uint8_t * bind140 = NULL;

                                                        listAssign(&bind138, serialReadList(list8Elem(bind5,(1 + 3))));
                                                        listAssign(&bind140, list8Cons(0,list8Cons(234,list8Cons(8,list8Cons(0,list8Cons(((uint8_t) list8Len(bind138)),bind138))))));
                                                        bind139 = 0;
                                                        while (1)
                                                            {
                                                            if (((((uint8_t) list8Elem(bind140,1)) == 126) || (((uint8_t) list8Elem(bind140,1)) == 125)))
                                                                {
                                                                serialWrite(0,125);
                                                                serialWrite(0,(list8Elem(bind140,1) ^ 32));
                                                                }
                                                            else
                                                                {
                                                                serialWrite(0,list8Elem(bind140,1));
                                                                }
                                                            if ((list8Len(bind140) == 2))
                                                                {
                                                                if (((((uint8_t) (list8Elem(bind140,0) + list8Elem(bind140,1))) == 126) || (((uint8_t) (list8Elem(bind140,0) + list8Elem(bind140,1))) == 125)))
                                                                    {
                                                                    serialWrite(0,125);
                                                                    serialWrite(0,((list8Elem(bind140,0) + list8Elem(bind140,1)) ^ 32));
                                                                    }
                                                                else
                                                                    {
                                                                    serialWrite(0,(list8Elem(bind140,0) + list8Elem(bind140,1)));
                                                                    }
                                                                break;
                                                                }
                                                            else
                                                                {
                                                                bind139 = 0;
                                                                listAssign(&bind140, list8Cons((list8Elem(bind140,0) + list8Elem(bind140,1)),list8Slice(bind140,2,0)));
                                                                }
                                                            }
                                                        serialWrite(0,126);
                                                        listRelease(&bind138);
                                                        listRelease(&bind140);
                                                        }
                                                    else
                                                        {
                                                        }
                                                    }
                                                else
                                                    {
                                                    if ((((uint8_t) list8Elem(bind5,0)) == 229))
                                                        {
                                                        if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                                            {
                                                            serialWrite(list8Elem(bind5,(1 + 2)),list8Elem(bind5,(1 + 5)));
                                                            }
                                                        else
                                                            {
                                                            }
                                                        }
                                                    else
                                                        {
                                                        if ((((uint8_t) list8Elem(bind5,0)) == 230))
                                                            {
                                                            if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 8) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 0) && ((list8Len(bind5) - 1) == (((int32_t) list8Elem(bind5,(1 + 5))) + 6)))))))
                                                                {
                                                                serialWriteList(list8Elem(bind5,(1 + 2)),list8Slice(list8Slice(bind5,1,0),6,0));
                                                                }
                                                            else
                                                                {
                                                                }
                                                            }
                                                        else
                                                            {
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                else
                                    {
                                    if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 96))
                                        {
                                        if ((((uint8_t) list8Elem(bind5,0)) == 96))
                                            {
                                            if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 3) && ((((uint8_t) list8Elem(bind5,(1 + 2))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 5))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 6))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 8))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 9))) == 0)))))))
                                                {
                                                uint8_t bind151;
                                                int32_t bind152;
                                                uint8_t * bind153 = NULL;

                                                bind151 = stepper2Pin(((((uint16_t) ((int32_t) list8Elem(bind5,(1 + 4)))) << 8) | ((uint16_t) ((int32_t) list8Elem(bind5,(1 + 3))))),list8Elem(bind5,(1 + 7)),list8Elem(bind5,(1 + 10)));
                                                listAssign(&bind153, list8Cons(0,list8Cons(104,list8Cons(2,list8Cons(0,list8Cons(bind151,(uint8_t * ) (const byte[]) {255, 0}))))));
                                                bind152 = 0;
                                                while (1)
                                                    {
                                                    if (((((uint8_t) list8Elem(bind153,1)) == 126) || (((uint8_t) list8Elem(bind153,1)) == 125)))
                                                        {
                                                        serialWrite(0,125);
                                                        serialWrite(0,(list8Elem(bind153,1) ^ 32));
                                                        }
                                                    else
                                                        {
                                                        serialWrite(0,list8Elem(bind153,1));
                                                        }
                                                    if ((list8Len(bind153) == 2))
                                                        {
                                                        if (((((uint8_t) (list8Elem(bind153,0) + list8Elem(bind153,1))) == 126) || (((uint8_t) (list8Elem(bind153,0) + list8Elem(bind153,1))) == 125)))
                                                            {
                                                            serialWrite(0,125);
                                                            serialWrite(0,((list8Elem(bind153,0) + list8Elem(bind153,1)) ^ 32));
                                                            }
                                                        else
                                                            {
                                                            serialWrite(0,(list8Elem(bind153,0) + list8Elem(bind153,1)));
                                                            }
                                                        break;
                                                        }
                                                    else
                                                        {
                                                        bind152 = 0;
                                                        listAssign(&bind153, list8Cons((list8Elem(bind153,0) + list8Elem(bind153,1)),list8Slice(bind153,2,0)));
                                                        }
                                                    }
                                                serialWrite(0,126);
                                                listRelease(&bind153);
                                                }
                                            else
                                                {
                                                }
                                            }
                                        else
                                            {
                                            if ((((uint8_t) list8Elem(bind5,0)) == 97))
                                                {
                                                if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 3) && ((((uint8_t) list8Elem(bind5,(1 + 2))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 5))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 6))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 8))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 9))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 11))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 12))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 14))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 15))) == 0)))))))))))
                                                    {
                                                    uint8_t bind159;
                                                    int32_t bind160;
                                                    uint8_t * bind161 = NULL;

                                                    bind159 = stepper4Pin(((((((uint16_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 24) | (((uint16_t) ((int32_t) list8Elem(bind5,(1 + 5)))) << 16)) | (((uint16_t) ((int32_t) list8Elem(bind5,(1 + 4)))) << 8)) | ((uint16_t) ((int32_t) list8Elem(bind5,(1 + 3))))),list8Elem(bind5,(1 + 7)),list8Elem(bind5,(1 + 10)),list8Elem(bind5,(1 + 13)),list8Elem(bind5,(1 + 16)));
                                                    listAssign(&bind161, list8Cons(0,list8Cons(104,list8Cons(2,list8Cons(0,list8Cons(bind159,(uint8_t * ) (const byte[]) {255, 0}))))));
                                                    bind160 = 0;
                                                    while (1)
                                                        {
                                                        if (((((uint8_t) list8Elem(bind161,1)) == 126) || (((uint8_t) list8Elem(bind161,1)) == 125)))
                                                            {
                                                            serialWrite(0,125);
                                                            serialWrite(0,(list8Elem(bind161,1) ^ 32));
                                                            }
                                                        else
                                                            {
                                                            serialWrite(0,list8Elem(bind161,1));
                                                            }
                                                        if ((list8Len(bind161) == 2))
                                                            {
                                                            if (((((uint8_t) (list8Elem(bind161,0) + list8Elem(bind161,1))) == 126) || (((uint8_t) (list8Elem(bind161,0) + list8Elem(bind161,1))) == 125)))
                                                                {
                                                                serialWrite(0,125);
                                                                serialWrite(0,((list8Elem(bind161,0) + list8Elem(bind161,1)) ^ 32));
                                                                }
                                                            else
                                                                {
                                                                serialWrite(0,(list8Elem(bind161,0) + list8Elem(bind161,1)));
                                                                }
                                                            break;
                                                            }
                                                        else
                                                            {
                                                            bind160 = 0;
                                                            listAssign(&bind161, list8Cons((list8Elem(bind161,0) + list8Elem(bind161,1)),list8Slice(bind161,2,0)));
                                                            }
                                                        }
                                                    serialWrite(0,126);
                                                    listRelease(&bind161);
                                                    }
                                                else
                                                    {
                                                    }
                                                }
                                            else
                                                {
                                                if ((((uint8_t) list8Elem(bind5,0)) == 98))
                                                    {
                                                    if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 4) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                                        {
                                                        stepperSetSpeed(list8Elem(bind5,(1 + 2)),((((((int32_t) ((int32_t) list8Elem(bind5,(1 + 8)))) << 24) | (((int32_t) ((int32_t) list8Elem(bind5,(1 + 7)))) << 16)) | (((int32_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 8)) | ((int32_t) ((int32_t) list8Elem(bind5,(1 + 5))))));
                                                        }
                                                    else
                                                        {
                                                        }
                                                    }
                                                else
                                                    {
                                                    if ((((uint8_t) list8Elem(bind5,0)) == 99))
                                                        {
                                                        if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 2))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 3) && (((uint8_t) list8Elem(bind5,(1 + 5))) == 0)))))
                                                            {
                                                            int32_t bind169;
                                                            uint8_t * bind170 = NULL;

                                                            stepperSetSpeed(list8Elem(bind5,(1 + 3)),((((int32_t) ((int32_t) list8Elem(bind5,(1 + 7)))) << 8) | ((int32_t) ((int32_t) list8Elem(bind5,(1 + 6))))));
                                                            listAssign(&bind170, list8Cons(0,list8Cons(106,(uint8_t * ) (const byte[]) {255, 0})));
                                                            bind169 = 0;
                                                            while (1)
                                                                {
                                                                if (((((uint8_t) list8Elem(bind170,1)) == 126) || (((uint8_t) list8Elem(bind170,1)) == 125)))
                                                                    {
                                                                    serialWrite(0,125);
                                                                    serialWrite(0,(list8Elem(bind170,1) ^ 32));
                                                                    }
                                                                else
                                                                    {
                                                                    serialWrite(0,list8Elem(bind170,1));
                                                                    }
                                                                if ((list8Len(bind170) == 2))
                                                                    {
                                                                    if (((((uint8_t) (list8Elem(bind170,0) + list8Elem(bind170,1))) == 126) || (((uint8_t) (list8Elem(bind170,0) + list8Elem(bind170,1))) == 125)))
                                                                        {
                                                                        serialWrite(0,125);
                                                                        serialWrite(0,((list8Elem(bind170,0) + list8Elem(bind170,1)) ^ 32));
                                                                        }
                                                                    else
                                                                        {
                                                                        serialWrite(0,(list8Elem(bind170,0) + list8Elem(bind170,1)));
                                                                        }
                                                                    break;
                                                                    }
                                                                else
                                                                    {
                                                                    bind169 = 0;
                                                                    listAssign(&bind170, list8Cons((list8Elem(bind170,0) + list8Elem(bind170,1)),list8Slice(bind170,2,0)));
                                                                    }
                                                                }
                                                            serialWrite(0,126);
                                                            listRelease(&bind170);
                                                            }
                                                        else
                                                            {
                                                            }
                                                        }
                                                    else
                                                        {
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    else
                                        {
                                        if ((((uint8_t) (list8Elem(bind5,0) & 240)) == 128))
                                            {
                                            if ((((uint8_t) list8Elem(bind5,0)) == 128))
                                                {
                                                if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 2))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 4))) == 3) && ((((uint8_t) list8Elem(bind5,(1 + 5))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 8))) == 3) && (((uint8_t) list8Elem(bind5,(1 + 9))) == 0)))))))
                                                    {
                                                    uint8_t bind177;
                                                    int32_t bind178;
                                                    uint8_t * bind179 = NULL;

                                                    bind177 = servoAttachMinMax(list8Elem(bind5,(1 + 3)),((((int16_t) ((int32_t) list8Elem(bind5,(1 + 7)))) << 8) | ((int16_t) ((int32_t) list8Elem(bind5,(1 + 6))))),((((int16_t) ((int32_t) list8Elem(bind5,(1 + 11)))) << 8) | ((int16_t) ((int32_t) list8Elem(bind5,(1 + 10))))));
                                                    listAssign(&bind179, list8Cons(0,list8Cons(136,list8Cons(2,list8Cons(0,list8Cons(bind177,(uint8_t * ) (const byte[]) {255, 0}))))));
                                                    bind178 = 0;
                                                    while (1)
                                                        {
                                                        if (((((uint8_t) list8Elem(bind179,1)) == 126) || (((uint8_t) list8Elem(bind179,1)) == 125)))
                                                            {
                                                            serialWrite(0,125);
                                                            serialWrite(0,(list8Elem(bind179,1) ^ 32));
                                                            }
                                                        else
                                                            {
                                                            serialWrite(0,list8Elem(bind179,1));
                                                            }
                                                        if ((list8Len(bind179) == 2))
                                                            {
                                                            if (((((uint8_t) (list8Elem(bind179,0) + list8Elem(bind179,1))) == 126) || (((uint8_t) (list8Elem(bind179,0) + list8Elem(bind179,1))) == 125)))
                                                                {
                                                                serialWrite(0,125);
                                                                serialWrite(0,((list8Elem(bind179,0) + list8Elem(bind179,1)) ^ 32));
                                                                }
                                                            else
                                                                {
                                                                serialWrite(0,(list8Elem(bind179,0) + list8Elem(bind179,1)));
                                                                }
                                                            break;
                                                            }
                                                        else
                                                            {
                                                            bind178 = 0;
                                                            listAssign(&bind179, list8Cons((list8Elem(bind179,0) + list8Elem(bind179,1)),list8Slice(bind179,2,0)));
                                                            }
                                                        }
                                                    serialWrite(0,126);
                                                    listRelease(&bind179);
                                                    }
                                                else
                                                    {
                                                    }
                                                }
                                            else
                                                {
                                                if ((((uint8_t) list8Elem(bind5,0)) == 129))
                                                    {
                                                    if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 1))) == 0)))
                                                        {
                                                        servoDetach(list8Elem(bind5,(1 + 2)));
                                                        }
                                                    else
                                                        {
                                                        }
                                                    }
                                                else
                                                    {
                                                    if ((((uint8_t) list8Elem(bind5,0)) == 130))
                                                        {
                                                        if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 3) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                                            {
                                                            servoWrite(list8Elem(bind5,(1 + 2)),((((int16_t) ((int32_t) list8Elem(bind5,(1 + 5)))) << 8) | ((int16_t) ((int32_t) list8Elem(bind5,(1 + 6))))));
                                                            }
                                                        else
                                                            {
                                                            }
                                                        }
                                                    else
                                                        {
                                                        if ((((uint8_t) list8Elem(bind5,0)) == 131))
                                                            {
                                                            if (((((uint8_t) list8Elem(bind5,(1 + 0))) == 2) && ((((uint8_t) list8Elem(bind5,(1 + 1))) == 0) && ((((uint8_t) list8Elem(bind5,(1 + 3))) == 3) && (((uint8_t) list8Elem(bind5,(1 + 4))) == 0)))))
                                                                {
                                                                servoWrite(list8Elem(bind5,(1 + 2)),((((int16_t) ((int32_t) list8Elem(bind5,(1 + 6)))) << 8) | ((int16_t) ((int32_t) list8Elem(bind5,(1 + 5))))));
                                                                }
                                                            else
                                                                {
                                                                }
                                                            }
                                                        else
                                                            {
                                                            if ((((uint8_t) list8Elem(bind5,0)) == 132))
                                                                {
                                                                if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                                                    {
                                                                    uint16_t bind191;
                                                                    int32_t bind192;
                                                                    uint8_t * bind193 = NULL;

                                                                    bind191 = servoRead(list8Elem(bind5,(1 + 3)));
                                                                    listAssign(&bind193, list8Cons(0,list8Cons(137,list8Cons(3,list8Cons(0,list8Cons(((uint8_t) ((int32_t) (bind191 & 255))),list8Cons(((uint8_t) ((int32_t) (bind191 >> 8))),(uint8_t * ) (const byte[]) {255, 0})))))));
                                                                    bind192 = 0;
                                                                    while (1)
                                                                        {
                                                                        if (((((uint8_t) list8Elem(bind193,1)) == 126) || (((uint8_t) list8Elem(bind193,1)) == 125)))
                                                                            {
                                                                            serialWrite(0,125);
                                                                            serialWrite(0,(list8Elem(bind193,1) ^ 32));
                                                                            }
                                                                        else
                                                                            {
                                                                            serialWrite(0,list8Elem(bind193,1));
                                                                            }
                                                                        if ((list8Len(bind193) == 2))
                                                                            {
                                                                            if (((((uint8_t) (list8Elem(bind193,0) + list8Elem(bind193,1))) == 126) || (((uint8_t) (list8Elem(bind193,0) + list8Elem(bind193,1))) == 125)))
                                                                                {
                                                                                serialWrite(0,125);
                                                                                serialWrite(0,((list8Elem(bind193,0) + list8Elem(bind193,1)) ^ 32));
                                                                                }
                                                                            else
                                                                                {
                                                                                serialWrite(0,(list8Elem(bind193,0) + list8Elem(bind193,1)));
                                                                                }
                                                                            break;
                                                                            }
                                                                        else
                                                                            {
                                                                            bind192 = 0;
                                                                            listAssign(&bind193, list8Cons((list8Elem(bind193,0) + list8Elem(bind193,1)),list8Slice(bind193,2,0)));
                                                                            }
                                                                        }
                                                                    serialWrite(0,126);
                                                                    listRelease(&bind193);
                                                                    }
                                                                else
                                                                    {
                                                                    }
                                                                }
                                                            else
                                                                {
                                                                if ((((uint8_t) list8Elem(bind5,0)) == 133))
                                                                    {
                                                                    if (((((uint8_t) list8Elem(bind5,(1 + 1))) == 2) && (((uint8_t) list8Elem(bind5,(1 + 2))) == 0)))
                                                                        {
                                                                        uint16_t bind199;
                                                                        int32_t bind200;
                                                                        uint8_t * bind201 = NULL;

                                                                        bind199 = servoReadMicros(list8Elem(bind5,(1 + 3)));
                                                                        listAssign(&bind201, list8Cons(0,list8Cons(137,list8Cons(3,list8Cons(0,list8Cons(((uint8_t) ((int32_t) (bind199 & 255))),list8Cons(((uint8_t) ((int32_t) (bind199 >> 8))),(uint8_t * ) (const byte[]) {255, 0})))))));
                                                                        bind200 = 0;
                                                                        while (1)
                                                                            {
                                                                            if (((((uint8_t) list8Elem(bind201,1)) == 126) || (((uint8_t) list8Elem(bind201,1)) == 125)))
                                                                                {
                                                                                serialWrite(0,125);
                                                                                serialWrite(0,(list8Elem(bind201,1) ^ 32));
                                                                                }
                                                                            else
                                                                                {
                                                                                serialWrite(0,list8Elem(bind201,1));
                                                                                }
                                                                            if ((list8Len(bind201) == 2))
                                                                                {
                                                                                if (((((uint8_t) (list8Elem(bind201,0) + list8Elem(bind201,1))) == 126) || (((uint8_t) (list8Elem(bind201,0) + list8Elem(bind201,1))) == 125)))
                                                                                    {
                                                                                    serialWrite(0,125);
                                                                                    serialWrite(0,((list8Elem(bind201,0) + list8Elem(bind201,1)) ^ 32));
                                                                                    }
                                                                                else
                                                                                    {
                                                                                    serialWrite(0,(list8Elem(bind201,0) + list8Elem(bind201,1)));
                                                                                    }
                                                                                break;
                                                                                }
                                                                            else
                                                                                {
                                                                                bind200 = 0;
                                                                                listAssign(&bind201, list8Cons((list8Elem(bind201,0) + list8Elem(bind201,1)),list8Slice(bind201,2,0)));
                                                                                }
                                                                            }
                                                                        serialWrite(0,126);
                                                                        listRelease(&bind201);
                                                                        }
                                                                    else
                                                                        {
                                                                        }
                                                                    }
                                                                else
                                                                    {
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        else
                                            {
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        // ******** Start of Instrumentation 
        if (cmdCount == TEST_COUNT)
            {           
            end = millis();
            sendStringf(""***TestEnd*** %d"", end - start);
            }
        // ******** End of Instrumentation            
        }
    taskComplete();
    }
",16130,True,5046.91091505268,median
"////////////////////////////////////////////////////////////////////////////////
//
//  ADOBE SYSTEMS INCORPORATED
//  Copyright 2003-2007 Adobe Systems Incorporated
//  All Rights Reserved.
//
//  NOTICE: Adobe permits you to use, modify, and distribute this file
//  in accordance with the terms of the license agreement accompanying it.
//
////////////////////////////////////////////////////////////////////////////////

package mx.preloaders
{

import flash.display.DisplayObject;
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.TimerEvent;
import flash.geom.Matrix;
import flash.geom.Rectangle;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.utils.Timer;
import flash.utils.getDefinitionByName;
import flash.utils.getTimer;
import mx.events.FlexEvent;
import mx.events.RSLEvent;
import mx.geom.RoundedRectangle;
import mx.graphics.RectangularDropShadow;


/**
 *  The DownloadProgressBar class displays download progress.
 *  It is used by the Preloader control to provide user feedback
 *  while the application is downloading and loading. 
 *
 *  <p>The download progress bar displays information about 
 *  two different phases of the application: 
 *  the download phase and the initialization phase. </p>
 *
 *  <p>In the Application container, use the 
 *  the <code>preloader</code> property to specify the name of your subclass.</p>
 *
 *  <p>You can implement a custom download progress bar component 
 *  by creating a subclass of the DownloadProgressBar class. 
 *  Do not implement a download progress bar as an MXML component 
 *  because it loads too slowly.</p>
 *
 *  @see mx.core.Application
 *  @see mx.preloaders.IPreloaderDisplay
 *  @see mx.preloaders.Preloader
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
public class DownloadProgressBar extends Sprite implements IPreloaderDisplay
{
    include ""../core/Version.as"";
    
    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------
    
    /**
     *  Constructor.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function DownloadProgressBar() 
    {
        super();
    }

    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------
    
    /**
     *  The minimum number of milliseconds
     *  that the display should appear visible.
     *  If the downloading and initialization of the application
     *  takes less time than this value, then Flex pauses for this amount
     *  of time before dispatching the <code>complete</code> event.
     *
     *  @default 0
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected var MINIMUM_DISPLAY_TIME:uint = 0;
    
    /**
     *  The percentage of the progress bar that the downloading phase
     *  fills when the SWF file is fully downloaded.
     *  The rest of the progress bar is filled during the initializing phase.
     *  This should be a value from 0 to 100. 
     *
     *  @default 60
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected var DOWNLOAD_PERCENTAGE:uint = 60;

    /**
     *  @private
     */
    private var _showProgressBar:Boolean = true;
        
    /**
     *  @private
     *  Cached Rectangle returned by the labelRect getter.
     */
    private var _labelRect:Rectangle = labelRect;

    /**
     *  @private
     *  Cached Rectangle returned by the percentRect getter.
     */
    private var _percentRect:Rectangle = percentRect;

    /**
     *  @private
     *  Cached RoundedRectangle returned by the borderRect getter.
     */
    private var _borderRect:RoundedRectangle = borderRect;

    /**
     *  @private
     *  Cached RoundedRectangle returned by the barFrameRect getter.
     */
    private var _barFrameRect:RoundedRectangle = barFrameRect;

    /**
     *  @private
     *  Cached RoundedRectangle returned by the barRect getter.
     */
    private var _barRect:RoundedRectangle = barRect; 
    
    /**
     *  @private
     */
    private var _xOffset:Number = 20;
    
    /**
     *  @private
     */
    private var _yOffset:Number = 20;
    
    /**
     *  @private
     */
    private var _maximum:Number = 0;
    
    /**
     *  @private
     */
    private var _value:Number = 0;
    
    /**
     *  @private
     */
    private var _barSprite:Sprite;

    /**
     *  @private
     */
    private var _barFrameSprite:Sprite;
    
    /**
     *  @private
     */
    private var _labelObj:TextField;

    /**
     *  @private
     */
    private var _percentObj:TextField;

    /**
     *  @private
     */
    private var _startTime:int;

    /**
     *  @private
     */
    private var _displayTime:int;
        
    /**
     *  @private
     */
    private var _startedLoading:Boolean = false;

    /**
     *  @private
     */
    private var _startedInit:Boolean = false;

    /**
     *  @private
     */
    private var _showingDisplay:Boolean = false;
    
    /**
     *  @private
     */
    private var _displayStartCount:uint = 0; 

    /**
     *  @private
     */
    private var _initProgressCount:uint = 0;

    /**
     *  The total number of validation events you expect to get
     *  in the initializing phase.  This should be an integer
     *  greater or equal to 4 (and note that if it is greater than 4
     *  you might have an inefficiency in your initialization code)
     *
     *  @default 6
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 4
     */
    protected var initProgressTotal:uint = 6;

    //--------------------------------------------------------------------------
    //
    //  Overridden properties
    //
    //--------------------------------------------------------------------------

    //----------------------------------
    //  visible
    //----------------------------------
    
    /**
     *  @private
     *  Storage for the visible property.
     */
    private var _visible:Boolean = false;

    /**
     *  Specifies whether the download progress bar is visible.
     *
     *  <p>When the Preloader control determines that the progress bar should be displayed, 
     *  it sets this value to <code>true</code>. When the Preloader control determines that
     *  the progress bar should be hidden, it sets the value to <code>false</code>.</p>
     *
     *  <p>A subclass of the DownloadProgressBar class should never modify this property. 
     *  Instead, you can override the setter method to recognize when 
     *  the Preloader control modifies it, and perform any necessary actions. </p>
     *
     *  @default false 
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    override public function get visible():Boolean
    {
        return _visible;
    }

    /**
     *  @private
     */
    override public function set visible(value:Boolean):void
    {
        if (!_visible && value) 
            show();
        
        else if (_visible && !value ) 
            hide();
        
        _visible = value;
    }
    
    //--------------------------------------------------------------------------
    //
    //  Properties: IPreloaderDisplay
    //
    //--------------------------------------------------------------------------
    
    //----------------------------------
    //  backgroundAlpha
    //----------------------------------

    /**
     *  @private
     *  Storage for the backgroundAlpha property.
     */
    private var _backgroundAlpha:Number = 1;

    /**
     *  Alpha level of the SWF file or image defined by 
     *  the <code>backgroundImage</code> property, or the color defined by 
     *  the <code>backgroundColor</code> property. 
     *  Valid values range from 0 to 1.0.    
     *
     *  <p>You can specify either a <code>backgroundColor</code> 
     *  or a <code>backgroundImage</code>, but not both.</p>
     *
     *  @default 1.0
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get backgroundAlpha():Number
    {
        if (!isNaN(_backgroundAlpha))
            return _backgroundAlpha;
        else
            return 1;
    }
    
    /**
     *  @private
     */
    public function set backgroundAlpha(value:Number):void
    {
        _backgroundAlpha = value;
    }
    
    //----------------------------------
    //  backgroundColor
    //----------------------------------

    /**
     *  @private
     *  Storage for the backgroundColor property.
     */
    private var _backgroundColor:uint;

    /**
     *  Background color of a download progress bar.
     *  You can have either a <code>backgroundColor</code> or a
     *  <code>backgroundImage</code>, but not both.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */ 
    public function get backgroundColor():uint
    {
        return _backgroundColor;
    }

    /**
     *  @private
     */
    public function set backgroundColor(value:uint):void
    {
        _backgroundColor = value;
    }
    
    //----------------------------------
    //  backgroundImage
    //----------------------------------

    /**
     *  @private
     *  Storage for the backgroundImage property.
     */
    private var _backgroundImage:Object;

    /**
     *  The background image of the application,
     *  which is passed in by the preloader.
     *  You can specify either a <code>backgroundColor</code> 
     *  or a <code>backgroundImage</code>, but not both.
     *
     *  <p>A value of null means ""not set"". 
     *  If this style and the <code>backgroundColor</code> style are undefined, 
     *  the component has a transparent background.</p>
     *
     *  <p>The preloader does not display embedded images. 
     *  You can only use images loaded at runtime.</p>
     *
     *  @default null
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get backgroundImage():Object
    {
        return _backgroundImage;
    }
    
    /**
     *  @private
     */
    public function set backgroundImage(value:Object):void
    {
        _backgroundImage = value;
    }
    
    //----------------------------------
    //  backgroundSize
    //----------------------------------

    /**
     *  @private
     *  Storage for the backgroundSize property.
     */
    private var _backgroundSize:String = """";

    /**
     *  Scales the image specified by <code>backgroundImage</code>
     *  to different percentage sizes.
     *  A value of <code>""100%""</code> stretches the image
     *  to fit the entire component.
     *  To specify a percentage value, you must include the percent sign (%).
     *  A value of <code>""auto""</code>, maintains
     *  the original size of the image.
     *
     *  @default ""auto""
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get backgroundSize():String
    {
        return _backgroundSize;
    }
    
    /**
     *  @private
     */
    public function set backgroundSize(value:String):void
    {
        _backgroundSize = value;
    }
    
    //----------------------------------
    //  preloader
    //----------------------------------

    /**
     *  @private
     *  Storage for the preloader property.
     */
    private var _preloader:Sprite; 
     
    /**
     *  The Preloader class passes in a reference to itself to the display class
     *  so that it can listen for events from the preloader.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function set preloader(value:Sprite):void
    {
        _preloader = value;
    
        value.addEventListener(ProgressEvent.PROGRESS, progressHandler);    
        value.addEventListener(Event.COMPLETE, completeHandler);
        
        value.addEventListener(RSLEvent.RSL_PROGRESS, rslProgressHandler);
        value.addEventListener(RSLEvent.RSL_COMPLETE, rslCompleteHandler);
        value.addEventListener(RSLEvent.RSL_ERROR, rslErrorHandler);
        
        value.addEventListener(FlexEvent.INIT_PROGRESS, initProgressHandler);
        value.addEventListener(FlexEvent.INIT_COMPLETE, initCompleteHandler);
    }

    //----------------------------------
    //  stageHeight
    //----------------------------------

    /**
     *  @private
     *  Storage for the stageHeight property.
     */
    private var _stageHeight:Number = 375;

    /**
     *  The height of the stage,
     *  which is passed in by the Preloader class.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get stageHeight():Number 
    {
        return _stageHeight;
    }

    /**
     *  @private
     */
    public function set stageHeight(value:Number):void 
    {
        _stageHeight = value;
    }
        
    //----------------------------------
    //  stageWidth
    //----------------------------------

    /**
     *  @private
     *  Storage for the stageHeight property.
     */
    private var _stageWidth:Number = 500;

    /**
     *  The width of the stage,
     *  which is passed in by the Preloader class.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get stageWidth():Number 
    {
        return _stageWidth;
    }
    
    /**
     *  @private
     */
    public function set stageWidth(value:Number):void 
    {
        _stageWidth = value;
    }
    
    //--------------------------------------------------------------------------
    //
    //  Properties
    //
    //--------------------------------------------------------------------------
    
    //----------------------------------
    //  barFrameRect
    //----------------------------------

    /**
     *  The dimensions of the progress bar border.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get barFrameRect():RoundedRectangle
    {
        return new RoundedRectangle(14, 40, 154, 4);
    }
    
    //----------------------------------
    //  barRect
    //----------------------------------

    /**
     *  The dimensions of the progress bar.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get barRect():RoundedRectangle
    {
        return new RoundedRectangle(14, 39, 154, 6, 0);
    }
    
    //----------------------------------
    //  borderRect
    //----------------------------------

    /**
     *  The dimensions of the border of the display.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get borderRect():RoundedRectangle
    {
        return new RoundedRectangle(0, 0, 182, 60, 4);
    }
    
    //----------------------------------
    //  downloadingLabel
    //----------------------------------

    /**
     *  @private
     *  Storage for the downloadingLabel property.
     */
    private var _downloadingLabel:String = ""Loading"";
    
    /**
     *  The string to display as the label while in the downloading phase.
     *
     *  @default ""Loading""
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get downloadingLabel():String
    {
        return _downloadingLabel;   
    }

    /**
     *  @private
     */
    protected function set downloadingLabel(value:String):void
    {
        _downloadingLabel = value;
    }
    
    //----------------------------------
    //  initializingLabel
    //----------------------------------
  
    /**
     *  @private
     *  Storage for the initializingLabel property.
     */
    private static var _initializingLabel:String = ""Initializing"";
  
    /**
     *  The string to display as the label while in the initializing phase.
     *
     *  @default ""Initializing""
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public static function get initializingLabel():String
    {
        return _initializingLabel;  
    }
  
    /**
     *  @private
     */
    public static function set initializingLabel(value:String):void
    {
        _initializingLabel = value;
    }   
    
    //----------------------------------
    //  label
    //----------------------------------

    /**
     *  @private
     *  Storage for the label property.
     */
    private var _label:String = """";

    /**
     *  Text to display when the progress bar is active.
     *  The Preloader class sets this value
     *  before displaying the progress bar.
     *  Implementing this property in a subclass is optional.
     *
     *  @default """"
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */ 
    protected function get label():String
    {
        return _label;
    }

    /**
     *  @private
     */
    protected function set label(value:String):void
    {
        if (!(value is Function))
            _label = value;

        draw();
    }
    
    //----------------------------------
    //  labelFormat
    //----------------------------------

    /**
     *  The TextFormat object of the TextField component of the label.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get labelFormat():TextFormat
    {
        var tf:TextFormat = new TextFormat();
        tf.color = 0x333333;
        tf.font = ""Verdana"";
        tf.size = 10;
        return tf;
    }

    //----------------------------------
    //  labelRect
    //----------------------------------

    /**
     *  The dimensions of the TextField component for the label. 
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get labelRect():Rectangle
    {
        return new Rectangle(14, 17, 100, 16);
    }
    
    //----------------------------------
    //  percentFormat
    //----------------------------------

    /**
     *  The TextFormat of the TextField component for displaying the percent.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get percentFormat():TextFormat
    {
        var tf:TextFormat = new TextFormat();
        tf.align = ""right"";
        tf.color  = 0x000000;
        tf.font = ""Verdana"";
        tf.size = 10;
        return tf;
    }
    
    //----------------------------------
    //  percentRect
    //----------------------------------

    /**
     *  The dimensions of the TextField component for displaying the percent.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get percentRect():Rectangle
    {
        return new Rectangle(108, 4, 34, 16);
    }
    
    //----------------------------------
    //  showLabel
    //----------------------------------
    
    /**
     *  @private
     *  Storage for the showLabel property.
     */
    private var _showLabel:Boolean = true;

    /**
     *  Controls whether to display the label, <code>true</code>, 
     *  or not, <code>false</code>.
     *
     *  @default true
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */ 
    protected function get showLabel():Boolean
    {
        return _showLabel;
    }
        
    /**
     *  @private
     */ 
    protected function set showLabel(value:Boolean):void
    {
        _showLabel = value;
        
        draw();
    }
    
    //----------------------------------
    //  showPercentage
    //----------------------------------

    /**
     *  @private
     *  Storage for the showPercentage property.
     */
    private var _showPercentage:Boolean = false;

    /**
     *  Controls whether to display the percentage, <code>true</code>, 
     *  or not, <code>false</code>.
     *
     *  @default true
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */ 
    protected function get showPercentage():Boolean
    {
        return _showPercentage;
    }

    /**
     *  @private
     */ 
    protected function set showPercentage(value:Boolean):void
    {
        _showPercentage = value;
        
        draw();
    }
        
    //--------------------------------------------------------------------------
    //
    //  Methods:IPreloaderDisplay
    //
    //--------------------------------------------------------------------------

    /**
     *  Called by the Preloader after the download progress bar
     *  has been added as a child of the Preloader. 
     *  This should be the starting point for configuring your download progress bar. 
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function initialize():void
    {
        _startTime = getTimer();
        
        center(stageWidth, stageHeight);
    }
    
    //--------------------------------------------------------------------------
    //
    //  Methods
    //
    //--------------------------------------------------------------------------
    
    /**
     *  Centers the download progress bar based on the passed in dimensions.
     *
     *  @param width The width of the area in which to center the download progress bar.
     *
     *  @param height The height of the area in which to center the download progress bar.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function center(width:Number, height:Number):void
    {
        _xOffset = Math.floor((width - _borderRect.width) / 2);
        _yOffset = Math.floor((height - _borderRect.height) / 2);
    }
    
    /**
     *  @private
     *  Updates the display.
     */
    private function draw():void
    {
        var percentage:Number;

        if (_startedLoading)
        {
            if (!_startedInit)
            {
                // 0 to MaxDL Percentage
                percentage = Math.round(getPercentLoaded(_value, _maximum) *
                                        DOWNLOAD_PERCENTAGE / 100);
            }
            else
            {
                // MaxDL percentage to 100
                percentage = Math.round((getPercentLoaded(_value, _maximum) *
                                        (100 - DOWNLOAD_PERCENTAGE) / 100) +
                                        DOWNLOAD_PERCENTAGE);
            }
        }
        else
        {
            percentage = getPercentLoaded(_value, _maximum);
        }
                
        if (_labelObj)
            _labelObj.text = _label;
        
        if (_percentObj)
        {
            if (!_showPercentage) 
            {
                _percentObj.visible = false;
                _percentObj.text = """";
            }
            else 
            {
                _percentObj.text = String(percentage) + ""%"";
            }
        }
        
        if (_barSprite && _barFrameSprite)
        {
            if (!_showProgressBar)  
            {
                _barSprite.visible = false;
                _barFrameSprite.visible = false;
            }
            else 
            {
                drawProgressBar(percentage);    
            }
        }
    }
    
    /**
     *  Creates the subcomponents of the display.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function createChildren():void
    {
        var g:Graphics = graphics;

        var labelObj:TextField;
        var percentObj:TextField;
        
        // Draw the background first
        // Same value as StyleManager.NOT_A_COLOR. However, we don't want to bring in StyleManager at this point. 
        if (backgroundColor != 0xFFFFFFFF)
        {
            g.beginFill(backgroundColor, backgroundAlpha);
            g.drawRect(0, 0, stageWidth, stageHeight);
        }
                
        if (backgroundImage != null)
            loadBackgroundImage(backgroundImage);
        
        _barFrameSprite = new Sprite();
        _barSprite = new Sprite();
        
        addChild(_barFrameSprite);  
        addChild(_barSprite);

        // Draw the outside border and fill.
        g.beginFill(0xCCCCCC, 0.4); 
        g.drawRoundRect(calcX(_borderRect.x),
                        calcY(_borderRect.y),
                        _borderRect.width,
                        _borderRect.height,
                        _borderRect.cornerRadius * 2,
                        _borderRect.cornerRadius * 2);
        g.drawRoundRect(calcX(_borderRect.x + 1),
                        calcY(_borderRect.y + 1),
                        _borderRect.width - 2,
                        _borderRect.height - 2,
                        _borderRect.cornerRadius - 1 * 2,
                        _borderRect.cornerRadius - 1 * 2);
        g.endFill();                

        g.beginFill(0xCCCCCC,0.4);
        g.drawRoundRect(calcX(_borderRect.x + 1),
                        calcY(_borderRect.y + 1),
                        _borderRect.width - 2,
                        _borderRect.height - 2,
                        _borderRect.cornerRadius - 1 * 2,
                        _borderRect.cornerRadius - 1 * 2);
        g.endFill();
        
        var frame_g:Graphics = _barFrameSprite.graphics;
        
        // Draw the bar frame border and fill
        var matrix:Matrix = new Matrix();
        matrix.createGradientBox(_barFrameRect.width, _barFrameRect.height,
                                 Math.PI / 2, calcX(_barFrameRect.x), calcY(_barFrameRect.y));
        
        frame_g.beginGradientFill(GradientType.LINEAR, 
                                  [ 0x5C6266, 0xB5B8BA ],
                                  [ 1.0, 1.0 ],
                                  [ 0, 0xFF ],
                                  matrix);
        frame_g.drawRoundRect(calcX(_barFrameRect.x),
                              calcY(_barFrameRect.y),
                              _barFrameRect.width,
                              _barFrameRect.height,
                              _barFrameRect.cornerRadius * 2,
                              _barFrameRect.cornerRadius * 2); 
        frame_g.drawRoundRect(calcX(_barFrameRect.x + 1),
                              calcY(_barFrameRect.y + 1),
                              _barFrameRect.width - 2,
                              _barFrameRect.height - 2,
                              _barFrameRect.cornerRadius * 2,
                              _barFrameRect.cornerRadius * 2);                    
        frame_g.endFill();                        

        // Attach the label TextField.
        _labelObj = new TextField();
        _labelObj.x = calcX(_labelRect.x);
        _labelObj.y = calcY(_labelRect.y);
        _labelObj.width = _labelRect.width;
        _labelObj.height = _labelRect.height;           
        _labelObj.selectable = false;
        _labelObj.defaultTextFormat = labelFormat;
        addChild(_labelObj);
        
        // Attach the percentage TextField.
        _percentObj = new TextField();
        _percentObj.x = calcX(_percentRect.x);
        _percentObj.y = calcY(_percentRect.y);
        _percentObj.width = _percentRect.width;
        _percentObj.height = _percentRect.height;           
        _percentObj.selectable = false;
        _percentObj.defaultTextFormat = percentFormat;
        addChild(_percentObj);
        
        // Create dropshadow
        var ds:RectangularDropShadow = new RectangularDropShadow();
        ds.color = 0x000000;
        ds.angle = 90;
        ds.alpha = .6;
        ds.distance = 2;
        ds.tlRadius = ds.trRadius = ds.blRadius = ds.brRadius = _borderRect.cornerRadius;
        ds.drawShadow(g, 
                      calcX(_borderRect.x),
                      calcY(_borderRect.y),
                      _borderRect.width,
                      _borderRect.height);
                              
        // Draw the top line        
        g.lineStyle(1,0xFFFFFF, .3);
        g.moveTo(calcX(_borderRect.x) + _borderRect.cornerRadius, calcY(_borderRect.y));
        g.lineTo(calcX(_borderRect.x) - _borderRect.cornerRadius + _borderRect.width, calcY(_borderRect.y));                  
    }
    
    /**
     *  @private
     *  Draws the progress bar.
     */
    private function drawProgressBar(percentage:Number):void
    {
        var g:Graphics = _barSprite.graphics;
        g.clear();
        
        var colors:Array = [ 0xFFFFFF, 0xFFFFFF ];
        var ratios:Array = [ 0, 0xFF ];
        var matrix:Matrix = new Matrix();
        
        // Middle
        var barWidth:Number = _barRect.width * percentage / 100;
        var barWidthSplit:Number = barWidth / 2;
        var barHeight:Number = _barRect.height-4;
        var barX:Number = calcX(_barRect.x);
        var barY:Number = calcY(_barRect.y) + 2;
        var barY2:Number;
        
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .39, .85],
                            ratios, matrix);
            
        g.drawRect(barX, barY, barWidthSplit, barHeight);       
                        
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX + barWidthSplit, barY);                
        g.beginGradientFill(GradientType.LINEAR, colors, [.85, 1.0],
                            ratios, matrix);                
        g.drawRect(barX + barWidthSplit, barY, barWidthSplit, barHeight);                       

        // Outer highlight
        barWidthSplit = barWidth / 3;
        barHeight = _barRect.height;
        barY = calcY(_barRect.y);
        barY2 = barY + barHeight - 1;
        
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .05, .15],
                            ratios, matrix);
            
        g.drawRect(barX, barY, barWidthSplit, 1);
        g.drawRect(barX, barY2, barWidthSplit, 1);
            
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX + barWidthSplit, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .15, .25],
                            ratios, matrix);
            
        g.drawRect(barX + barWidthSplit, barY, barWidthSplit, 1);
        g.drawRect(barX + barWidthSplit, barY2, barWidthSplit, 1);
                            
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX + barWidthSplit * 2, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .25, .1],
                            ratios, matrix);
            
        g.drawRect(barX + barWidthSplit * 2, barY, barWidthSplit, 1);
        g.drawRect(barX + barWidthSplit * 2, barY2, barWidthSplit, 1);                  
        
        // Inner highlight
        barWidthSplit = barWidth / 3;
        barHeight = _barRect.height;
        barY = calcY(_barRect.y) + 1;
        barY2 = calcY(_barRect.y) + barHeight - 2;
        
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .15, .30],
                            ratios, matrix);
            
        g.drawRect(barX, barY, barWidthSplit, 1);
        g.drawRect(barX, barY2, barWidthSplit, 1);
            
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX + barWidthSplit, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .30, .40],
                            ratios, matrix);
            
        g.drawRect(barX + barWidthSplit, barY, barWidthSplit, 1);
        g.drawRect(barX + barWidthSplit, barY2, barWidthSplit, 1);
                            
        matrix.createGradientBox(barWidthSplit, barHeight,
                                 0, barX + barWidthSplit * 2, barY);
        g.beginGradientFill(GradientType.LINEAR, colors, [ .40, .25],
                            ratios, matrix);
            
        g.drawRect(barX + barWidthSplit * 2, barY, barWidthSplit, 1);
        g.drawRect(barX + barWidthSplit * 2, barY2, barWidthSplit, 1);  
    }

    /**
     *  Updates the display of the download progress bar
     *  with the current download information. 
     *  A typical implementation divides the loaded value by the total value
     *  and displays a percentage.
     *  If you do not implement this method, you should create
     *  a progress bar that displays an animation to indicate to the user
     *  that a download is occurring.
     *
     *  <p>The <code>setProgress()</code> method is only called
     *  if the application is being downloaded from a remote server
     *  and the application is not in the browser cache.</p>
     *
     *  @param completed Number of bytes of the application SWF file
     *  that have been downloaded.
     *
     *  @param total Size of the application SWF file in bytes.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function setProgress(completed:Number, total:Number):void
    {
        if (!isNaN(completed) && 
           !isNaN(total) &&
           completed >= 0 && 
           total > 0)
        {
            _value = Number(completed);
            _maximum = Number(total);
            draw();
        }   
    }   
    
    /**
     *  Returns the percentage value of the application loaded. 
     *
     *  @param loaded Number of bytes of the application SWF file
     *  that have been downloaded.
     *
     *  @param total Size of the application SWF file in bytes.
     *
     *  @return The percentage value of the loaded application.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function getPercentLoaded(loaded:Number, total:Number):Number
    {
        var perc:Number;
        
        if (loaded == 0 || total == 0 || isNaN(total) || isNaN(loaded))
            return 0;
        else 
            perc = 100 * loaded/total;

        if (isNaN(perc) || perc <= 0)
            return 0;
        else if (perc > 99)
            return 99;
        else
            return Math.round(perc);
    }
    
    /**
     *  @private
     *  Make the display class visible.
     */
    private function show():void
    {
        _showingDisplay = true;
        calcScale();
        draw();
        _displayTime = getTimer(); // Time when the display is shown.
    }
    
    /**
     *  @private
     */
    private function hide():void
    {
    }
    
    /**
     *  @private
     */
    private function calcX(base:Number):Number
    {
        return base + _xOffset;
    }
    
    /**
     *  @private
     */
    private function calcY(base:Number):Number
    {
        return base + _yOffset;
    }
    
    /**
     *  @private
     *  Figure out the scale for the display class based on the stage size.
     *  Then creates the children subcomponents.
     */
    private function calcScale():void
    {
        if (stageWidth < 160 || stageHeight < 120)
        {
            scaleX = 1.0;
            scaleY = 1.0;
        }
        else if (stageWidth < 240 || stageHeight < 150)
        {
            // Scale to appropriate size
            createChildren();
            var scale:Number = Math.min(stageWidth / 240.0,
                                        stageHeight / 150.0);
            scaleX = scale;
            scaleY = scale;
        }
        else
        {
            createChildren();
        }
    }
    
    /**
     *  Defines the algorithm for determining whether to show
     *  the download progress bar while in the download phase.
     *
     *  @param elapsedTime number of milliseconds that have elapsed
     *  since the start of the download phase.
     *
     *  @param event The ProgressEvent object that contains
     *  the <code>bytesLoaded</code> and <code>bytesTotal</code> properties.
     *
     *  @return If the return value is <code>true</code>, then show the 
     *  download progress bar.
     *  The default behavior is to show the download progress bar 
     *  if more than 700 milliseconds have elapsed
     *  and if Flex has downloaded less than half of the bytes of the SWF file.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function showDisplayForDownloading(elapsedTime:int,
                                              event:ProgressEvent):Boolean
    {
        return elapsedTime > 700 &&
            event.bytesLoaded < event.bytesTotal / 2;
    }
    
    /**
     *  Defines the algorithm for determining whether to show the download progress bar
     *  while in the initialization phase, assuming that the display
     *  is not currently visible.
     *
     *  @param elapsedTime number of milliseconds that have elapsed
     *  since the start of the download phase.
     *
     *  @param count number of times that the <code>initProgress</code> event
     *  has been received from the application.
     *
     *  @return If <code>true</code>, then show the download progress bar.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function showDisplayForInit(elapsedTime:int, count:int):Boolean
    {
        return elapsedTime > 300 && count == 2;
    }
    
    /**
     *  @private
     */
    private function loadBackgroundImage(classOrString:Object):void
    {
        var cls:Class;
        
        // The ""as"" operator checks to see if classOrString
        // can be coerced to a Class
        if (classOrString && classOrString as Class)
        {
            // Load background image given a class pointer
            cls = Class(classOrString);
            initBackgroundImage(new cls());
        }
        else if (classOrString && classOrString is String)
        {
            try
            {
                cls = Class(getDefinitionByName(String(classOrString)));
            }
            catch(e:Error)
            {
                // ignore
            }

            if (cls)
            {
                var newStyleObj:DisplayObject = new cls();
                initBackgroundImage(newStyleObj);
            }
            else
            {
                // Loading the image is slightly different
                // than in Loader.loadContent()... is this on purpose?

                // Load background image from external URL
                var loader:Loader = new Loader();
                loader.contentLoaderInfo.addEventListener(
                    Event.COMPLETE, loader_completeHandler);
                loader.contentLoaderInfo.addEventListener(
                    IOErrorEvent.IO_ERROR, loader_ioErrorHandler);  
                var loaderContext:LoaderContext = new LoaderContext();
                loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
                loader.load(new URLRequest(String(classOrString)), loaderContext);      
            }
        }
    }
    
    /**
     *  @private
     */
    private function initBackgroundImage(image:DisplayObject):void
    {
        addChildAt(image,0);
        
        var backgroundImageWidth:Number = image.width;
        var backgroundImageHeight:Number = image.height;
        
        // Scale according to backgroundSize
        var percentage:Number = calcBackgroundSize();
        if (isNaN(percentage))
        {
            var sX:Number = 1.0;
            var sY:Number = 1.0;
        }
        else
        {
            var scale:Number = percentage * 0.01;
            sX = scale * stageWidth / backgroundImageWidth;
            sY = scale * stageHeight / backgroundImageHeight;
        }
        
        image.scaleX = sX;
        image.scaleY = sY;

        // Center everything.
        // Use a scrollRect to position and clip the image.
        var offsetX:Number =
            Math.round(0.5 * (stageWidth - backgroundImageWidth * sX));
        var offsetY:Number =
            Math.round(0.5 * (stageHeight - backgroundImageHeight * sY));

        image.x = offsetX;
        image.y = offsetY;

        // Adjust alpha to match backgroundAlpha
        if (!isNaN(backgroundAlpha))
            image.alpha = backgroundAlpha;
    }
    
    /**
     *  @private
     */
    private function calcBackgroundSize():Number
    {   
        var percentage:Number = NaN;
        
        if (backgroundSize)
        {
            var index:int = backgroundSize.indexOf(""%"");
            if (index != -1)
                percentage = Number(backgroundSize.substr(0, index));
        }
        
        return percentage;
    }

    //--------------------------------------------------------------------------
    //
    //  Event handlers
    //
    //--------------------------------------------------------------------------
    
    /**
     *  Event listener for the <code>ProgressEvent.PROGRESS</code> event. 
     *  This implementation updates the progress bar
     *  with the percentage of bytes downloaded.
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function progressHandler(event:ProgressEvent):void
    {
        var loaded:uint = event.bytesLoaded;
        var total:uint = event.bytesTotal;

        var elapsedTime:int = getTimer() - _startTime;
        
        // Only show the Loading phase if it will appear for awhile.
        if (_showingDisplay || showDisplayForDownloading(elapsedTime, event))       
        {
            if (!_startedLoading)
            {
                show();
                label = downloadingLabel;       
                _startedLoading = true;
            }

            setProgress(event.bytesLoaded, event.bytesTotal);
        }
    }
    
    /**
     *  Event listener for the <code>Event.COMPLETE</code> event. 
     *  The default implementation does nothing.
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function completeHandler(event:Event):void
    {
    }
    
    /**
     *  Event listener for the <code>RSLEvent.RSL_PROGRESS</code> event. 
     *  The default implementation does nothing.
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function rslProgressHandler(event:RSLEvent):void
    {
    }
    
    /**
     *  Event listener for the <code>RSLEvent.RSL_COMPLETE</code> event. 
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function rslCompleteHandler(event:RSLEvent):void
    {
        var word:String = ""library"";
        if (event.isResourceModule)
            word = ""module"";

        label = ""Loaded "" + word + "" "" + event.rslIndex + "" of "" + event.rslTotal;
    }
    
    /**
     *  Event listener for the <code>RSLEvent.RSL_ERROR</code> event. 
     *  This event listner handles any errors detected when downloading an RSL.
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function rslErrorHandler(event:RSLEvent):void
    {
        _preloader.removeEventListener(ProgressEvent.PROGRESS,
                                       progressHandler);    
        
        _preloader.removeEventListener(Event.COMPLETE,
                                       completeHandler);
        
        _preloader.removeEventListener(RSLEvent.RSL_PROGRESS,
                                       rslProgressHandler);

        _preloader.removeEventListener(RSLEvent.RSL_COMPLETE,
                                       rslCompleteHandler);

        _preloader.removeEventListener(RSLEvent.RSL_ERROR,
                                       rslErrorHandler);
        
        _preloader.removeEventListener(FlexEvent.INIT_PROGRESS,
                                       initProgressHandler);

        _preloader.removeEventListener(FlexEvent.INIT_COMPLETE,
                                       initCompleteHandler);
    
        if (!_showingDisplay)
        {
            show();
            _showingDisplay = true;
        }

        label = ""RSL Error "" + (event.rslIndex + 1) + "" of "" + event.rslTotal;
        
        var errorField:ErrorField = new ErrorField(this);
        errorField.show(event.errorText);
    }
    
    /**
     *  @private
     *  Helper function that dispatches the Complete event to the preloader.
     *
     *  @param event The event object.
     */
    private function timerHandler(event:Event = null):void
    {
        dispatchEvent(new Event(Event.COMPLETE)); 
    }
    
    /**
     *  Event listener for the <code>FlexEvent.INIT_PROGRESS</code> event. 
     *  This implementation updates the progress bar
     *  each time the event is dispatched, and changes the text of the label. 
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function initProgressHandler(event:Event):void
    {
        var elapsedTime:int = getTimer() - _startTime;
        _initProgressCount++;
        
        if (!_showingDisplay &&
            showDisplayForInit(elapsedTime, _initProgressCount))
        {
            _displayStartCount = _initProgressCount;
            show();
        }

        if (_showingDisplay)
        {
            if (!_startedInit)
            {
                // First init progress event.
                _startedInit = true;
                label = initializingLabel;
            }

            var loaded:Number = 100 * _initProgressCount /
                                (initProgressTotal - _displayStartCount);

            setProgress(Math.min(loaded, 100), 100);
        }
    }
    
    /**
     *  Event listener for the <code>FlexEvent.INIT_COMPLETE</code> event. 
     *
     *  @param event The event object.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function initCompleteHandler(event:Event):void
    {
        var elapsedTime:int = getTimer() - _displayTime;
        
        if (_showingDisplay && elapsedTime < MINIMUM_DISPLAY_TIME)
        {
            var timer:Timer = new Timer(MINIMUM_DISPLAY_TIME - elapsedTime, 1);
            timer.addEventListener(TimerEvent.TIMER, timerHandler);
            timer.start();
        }
        else
        {
            timerHandler();
        }
    }

    /**
     *  @private
     */
    private function loader_completeHandler(event:Event):void
    {
        var target:DisplayObject = DisplayObject(LoaderInfo(event.target).loader);
        
        initBackgroundImage(target);
    }
    
    private function loader_ioErrorHandler(event:IOErrorEvent):void
    {
        // Swallow the error
    }
    
}

}

import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.system.Capabilities;
import flash.text.TextFieldAutoSize;
import flash.display.DisplayObjectContainer;
import flash.display.Stage;
import mx.preloaders.DownloadProgressBar;


    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------
    
/**
 * @private
 * 
 * Area to display error messages to help debug startup problems.
 * 
 */
class ErrorField extends Sprite
{
    private var downloadProgressBar:DownloadProgressBar;
    private const MIN_WIDTH_INCHES:int = 2;                    // min width of error message in inches
    private const MAX_WIDTH_INCHES:int = 6;                    // max width of error message in inches
    private const TEXT_MARGIN_PX:int = 10;
    
    
    //----------------------------------
    //  labelFormat
    //----------------------------------

    /**
     *  The TextFormat object of the TextField component of the label.
     *  This is a read-only property which you must override
     *  if you need to change it.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    protected function get labelFormat():TextFormat
    {
        var tf:TextFormat = new TextFormat();
        tf.color = 0x000000;        
        tf.font = ""Verdana"";
        tf.size = 10;
        return tf;
    }

   
   /**
   * @private
   * 
   * @param - parent - parent of the error field.
   */ 
    public function ErrorField(downloadProgressBar:DownloadProgressBar)
    {
        super();
        this.downloadProgressBar = downloadProgressBar;
    }
    
    
    /**
    * Create and show the error message.
    * 
    * @param errorText - text for error message.
    *  
    *  @langversion 3.0
    *  @playerversion Flash 9
    *  @playerversion AIR 1.1
    *  @productversion Flex 3
    */
    public function show(errorText:String):void
    {
        if (errorText == null || errorText.length == 0)
            return;
            
        var screenWidth:Number = downloadProgressBar.stageWidth;
        var screenHeight:Number = downloadProgressBar.stageHeight;
        
        // create the text field for the message and 
        // add it to the parent.
        var textField:TextField = new TextField();
        
        textField.autoSize = TextFieldAutoSize.LEFT;
        textField.multiline = true;
        textField.wordWrap = true;
        textField.background = true;
        textField.defaultTextFormat = labelFormat;
        textField.text = errorText;

        textField.width = Math.max(MIN_WIDTH_INCHES * Capabilities.screenDPI, screenWidth - (TEXT_MARGIN_PX * 2));
        textField.width = Math.min(MAX_WIDTH_INCHES * Capabilities.screenDPI, textField.width);
        textField.y = Math.max(0, screenHeight - TEXT_MARGIN_PX - textField.height);
        
        // center field horizontally
        textField.x = (screenWidth - textField.width) / 2;
        
        downloadProgressBar.parent.addChild(this);
        this.addChild(textField);
                
    }
}
",12346,True,2555.359394353211,median
"package
{
	import away3d.containers.*;
	import away3d.core.math.MathConsts;
	import Box2D.Collision.Shapes.b2CircleShape;
	import Box2D.Collision.Shapes.b2PolygonShape;
	import Box2D.Collision.Shapes.b2Shape;
	import Box2D.Common.Math.b2Vec2;
	import Box2D.Dynamics.b2Body;
	import Box2D.Dynamics.b2BodyDef;
	import Box2D.Dynamics.b2ContactListener;
	import Box2D.Dynamics.b2Fixture;
	import Box2D.Dynamics.b2FixtureDef;
	import Box2D.Dynamics.b2World;
	import Box2D.Dynamics.Contacts.b2Contact;
	import com.noteflight.standingwave3.filters.ResamplingFilter;
	import flash.media.SoundChannel;
	import flash.media.SoundMixer;
	import flash.media.SoundTransform;
	import flash.net.SharedObject;
	import flash.ui.Multitouch;
	import flash.ui.MultitouchInputMode;
	import com.noteflight.standingwave3.elements.*;
	import com.noteflight.standingwave3.output.*;
	import com.noteflight.standingwave3.sources.*;
	import com.noteflight.standingwave3.filters.GainFilter;
	import com.noteflight.standingwave3.filters.EchoFilter;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import flash.media.Sound;
	import Game.GeneralObject;
	import Game.Player;
	import starling.animation.Tween;
	import away3d.core.managers.Stage3DManager;
	import away3d.core.managers.Stage3DProxy;
	import away3d.entities.*;
	import away3d.events.LoaderEvent;
	import away3d.events.Stage3DEvent;
	import away3d.loaders.Loader3D;
	import away3d.loaders.misc.AssetLoaderContext;
	import away3d.loaders.parsers.OBJParser;
	import away3d.materials.*;
	import away3d.primitives.*;
	import away3d.utils.*;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.text.engine.TextBlock;
	import starling.core.*;
	
	import flash.display.*;
	import flash.events.*;
	import flash.geom.Vector3D;

	[SWF(backgroundColor=""#000000"", frameRate=""60"", quality=""LOW"")]
	[Frame(factoryClass='Preloader')] // name of preloader class
	public class Basic_View extends Sprite
	{
		// mug
		[Embed(source=""assets/models/mug/mug.obj"", mimeType=""application/octet-stream"")]
		private var MugModel:Class;
		[Embed(source=""assets/models/mug/mug.mtl"", mimeType=""application/octet-stream"")]
		private var MugMTL:Class;
		[Embed(source=""assets/models/mug/mug.jpg"", mimeType=""image/jpg"")]
		private var MugTexture:Class;
		
		[Embed(source=""assets/models/coin/coin.obj"", mimeType=""application/octet-stream"")] private var CoinModel:Class;
		[Embed(source=""assets/models/coin/coin.mtl"", mimeType=""application/octet-stream"")] private var CoinMTL:Class;
		[Embed(source=""assets/models/coin/coingold.jpg"", mimeType=""image/jpg"")] private var CoinGoldTexture:Class;
		[Embed(source=""assets/models/coin/coinsilver.jpg"", mimeType=""image/jpg"")] private var CoinSilverTexture:Class;
		[Embed(source=""assets/models/coin/coincopper.jpg"", mimeType=""image/jpg"")] private var CoinCopperTexture:Class;
		
		[Embed(source=""assets/models/star/star.obj"", mimeType=""application/octet-stream"")] private var StarModel:Class;
		[Embed(source=""assets/models/star/star.mtl"", mimeType=""application/octet-stream"")] private var StarMTL:Class;
		[Embed(source=""assets/models/star/star.png"", mimeType=""image/png"")] private var StarTexture:Class;
		
		[Embed(source=""assets/models/clock/clock.obj"", mimeType=""application/octet-stream"")] private var ClockModel:Class;
		[Embed(source=""assets/models/clock/clock.mtl"", mimeType=""application/octet-stream"")] private var ClockMTL:Class;
		[Embed(source=""assets/models/clock/clock.jpg"", mimeType=""image/jpg"")] private var ClockTexture:Class;
		
		[Embed(source=""assets/models/barstool/barstool.obj"", mimeType=""application/octet-stream"")] private var BarStoolModel:Class;
		[Embed(source=""assets/models/barstool/barstool.mtl"", mimeType=""application/octet-stream"")] private var BarStoolMTL:Class;
		[Embed(source=""assets/models/barstool/barstool_small.jpg"", mimeType=""image/jpg"")] private var BarStoolTexture:Class;
		
		[Embed(source=""assets/models/plant/plant.obj"", mimeType=""application/octet-stream"")] private var PlantModel:Class;
		[Embed(source=""assets/models/plant/plant.mtl"", mimeType=""application/octet-stream"")] private var PlantMTL:Class;
		[Embed(source=""assets/models/plant/plant.jpg"", mimeType=""image/jpg"")] private var PlantTexture:Class;
		
		[Embed(source=""assets/models/neon/neonskyline.obj"", mimeType=""application/octet-stream"")] private var NeonSkylineModel:Class;
		[Embed(source=""assets/models/neon/neonskyline.mtl"", mimeType=""application/octet-stream"")] private var NeonSkylineMTL:Class;
		[Embed(source=""assets/models/neon/neon.jpg"", mimeType=""image/jpg"")] private var NeonSkylineTexture:Class;
		
		[Embed(source=""assets/models/billards/pool.obj"", mimeType=""application/octet-stream"")] private var BillardsModel:Class;
		[Embed(source=""assets/models/billards/pool.mtl"", mimeType=""application/octet-stream"")] private var BillardsMTL:Class;
		[Embed(source=""assets/models/billards/pool.jpg"", mimeType=""image/jpg"")] private var BillardsTexture:Class;
		
		[Embed(source=""assets/models/counter/counter.obj"", mimeType=""application/octet-stream"")] private var CounterModel:Class;
		[Embed(source=""assets/models/counter/counter.mtl"", mimeType=""application/octet-stream"")] private var CounterMTL:Class;
		[Embed(source=""assets/models/counter/counter.jpg"", mimeType=""image/jpg"")] private var CounterTexture:Class;
		
		//plane texture
		[Embed(source=""assets/textures/floor_diffuse.jpg"")]
		public static var FloorDiffuse:Class;
		[Embed(source=""assets/textures/win.jpg"")]
		public static var FloorWin:Class;
		//plane texture
		[Embed(source=""assets/textures/grass_diffuse.jpg"")]
		public static var GrassDiffuse:Class;
		//plane texture
		[Embed(source=""assets/textures/checker.jpg"")] public static var CheckerFloorDiffuse:Class;
		[Embed(source=""assets/textures/bricks_small.jpg"")] public static var BricksDiffuse:Class;
		
		private var mouseAccelY:int = 0, mouseAccelX:int = 0;
		private var title_pan_cam:Number = 0, enteredLevel:Boolean = false;
		
		// Stage manager and proxy instances
		private var stage3DManager:Stage3DManager;
		private var stage3DProxy:Stage3DProxy;
		
		static public var sharedOBJ:SharedObject;
		static public var globalMouseX:int=0, globalMouseY:int=0;
		static public var playerX:int=0, playerY:int=0;
		static public var restart:Boolean = false;
		static private var _setLevel:int = -1;
		
		//private var starlingBackground:Starling;
		private var starlingForeground:Starling;
		//private var hoverController:HoverController;
		
		//engine variables
		private var _view:View3D;
		
		// physics
		public var world:b2World;
		static public var worldScale:Number = 0.04;
		
		// 2d
		private var hud:HUD, setuphud:Boolean = false;
		
		// scene objects
		private var _mug:Loader3D;
		private var _turtlegun:Loader3D;
		
		private var player:Player;
		public var cameraDisplacementMag:Number, cameraDirection:Number;
		
		static public var currentLevel:int = -1;
		
		// game logic
		public var lastLevel:int = -1; // if this is the same as the current level during loading, you can just use the reset nethod to avoid recreating the level geometry
		
		private var goal:int = 0, goal_reset:int = 90, inGoal:Boolean = false;
		private var keySpace:Boolean = false;
		static public var endLevel:Boolean=false, unloaded_solidlist:Array = new Array, solidlist:Array = new Array; // contains Rectangle bounding boxes of all solid objects
		private var stars:int = 0, coins:int = 0, totalcoins:int = 0;
		public var goallist:Array = new Array, coinsCollected:Array;
		public var pickuplist:Array = new Array;
		public var animationlist:Array = new Array;
		public var boxQueue:Array = new Array, floorQueue:Array = new Array, reloadMapData:Array, pickupQueue:Array = [new Array, new Array, new Array, new Array], pickupQueueInactive:Array = [new Array, new Array, new Array, new Array]; // gold coin, silver coin, copper count, star, same as the id property on pickups
		public var boxQueueActive:Array = new Array, floorQueueActive:Array = new Array;
		private var previewCourse:Boolean = true;
		private var faraway:int = -10000; // set object coordinates to faraway to get them off the screen
		
		private var audioplayer:AudioPlayer, audioplayer2:AudioPlayer, music:Sound, musicchannel:SoundChannel, music_updated:Boolean = true;
		private var sound_soda:IAudioSource, sound_coin:IAudioSource, sound_button:IAudioSource, sound_thud:IAudioSource, sound_thud2:IAudioSource, sound_coindrop:IAudioSource, sound_star:IAudioSource, sound_countdown:IAudioSource;
		static public var play_sound_coindrop:Boolean = false, play_sound_button:Boolean = false;
		
		// Textures
		private var gameWoodFloorTexture:TextureMaterial, gameWinFloorTexture:TextureMaterial, gameBoxDiffuse:TextureMaterial;
		//private var goldCoinTexture:TextureMaterial, silverCoinTexture:TextureMaterial, copperCoinTexture:TextureMaterial, starTexture:TextureMaterial;
		
		static public var room:int = 0;
		private var contactListener:ContactListener;
		
		private var tutorialmode:int = -1;
		
		public function getMainLoaderInfo():LoaderInfo {
			var loaderInfo:LoaderInfo = root.loaderInfo;
			if (loaderInfo.loader != null) {
				loaderInfo = loaderInfo.loader.loaderInfo;
			}
			return loaderInfo;
		}
		/**
		 * Constructor
		 */
		public function Basic_View()
		{
			if (stage) init(null);
			else addEventListener(Event.ADDED_TO_STAGE, init);
			
		}
		
		static public function setLevel(lvl:int):void {
			_setLevel = lvl;
		}
		
		private function SetupScene():void {
			var textureMaterialWall:TextureMaterial = new TextureMaterial(Cast.bitmapTexture(BricksDiffuse));
			var textureMaterial:TextureMaterial =  new TextureMaterial(Cast.bitmapTexture(CheckerFloorDiffuse));
			for (var xx:int = 0; xx < 12; xx++) {
				var wall:Mesh = new Mesh(new PlaneGeometry(800, 800), textureMaterialWall);
				wall.rotationX = -90;
				wall.x = -800 * 6 + xx * 800;
				wall.y = 0;
				wall.z = 800*3;
				_view.scene.addChild(wall);
				
				for (var yy:int = 0; yy < 7; yy++) {
					var plane:Mesh = new Mesh(new PlaneGeometry(800, 800), textureMaterial);
					plane.x = -800*6 + xx*800;
					plane.z = -800*3 + yy*800;
					plane.y = -400;
					
					_view.scene.addChild(plane);
				}
			}
			
			// place clock
			
			var clockLoaderContent:AssetLoaderContext = new AssetLoaderContext();
			clockLoaderContent.mapUrlToData(""clock.mtl"", new ClockMTL());
			clockLoaderContent.mapUrlToData(""clock.jpg"", new ClockTexture());
			var _clock:Loader3D = new Loader3D();
			_clock.scale(100);
			_clock.loadData(new ClockModel(), clockLoaderContent, null, new OBJParser(1));
			_clock.y = 200;
			_clock.rotationY = 180;
			_clock.rotationX = 90;
			_clock.x = -400;
			_clock.z = 2400;
			_view.scene.addChild(_clock);
			
			var plantLoaderContent:AssetLoaderContext = new AssetLoaderContext();
			plantLoaderContent.mapUrlToData(""plant.mtl"", new PlantMTL());
			plantLoaderContent.mapUrlToData(""plant.jpg"", new PlantTexture());
			var _plant:Loader3D = new Loader3D();
			_plant.scale(250);
			_plant.loadData(new PlantModel(), plantLoaderContent, null, new OBJParser(1));
			_plant.y = -420;
			_plant.rotationY = 70;
			_plant.x = 2200;
			_plant.z = 2000;
			_view.scene.addChild(_plant);
			
			var neonskylineLoaderContent:AssetLoaderContext = new AssetLoaderContext();
			neonskylineLoaderContent.mapUrlToData(""neonskyline.mtl"", new NeonSkylineMTL());
			neonskylineLoaderContent.mapUrlToData(""neon.jpg"", new NeonSkylineTexture());
			var _neon:Loader3D = new Loader3D();
			_neon.scale(80);
			_neon.loadData(new NeonSkylineModel(), neonskylineLoaderContent, null, new OBJParser(1));
			_neon.rotationX = -90;
			_neon.y = -100;
			_neon.x = 1100;
			_neon.z = 2350;
			_view.scene.addChild(_neon);
			
			var billardsLoaderContent:AssetLoaderContext = new AssetLoaderContext();
			billardsLoaderContent.mapUrlToData(""pool.mtl"", new BillardsMTL());
			billardsLoaderContent.mapUrlToData(""pool.jpg"", new BillardsTexture());
			var _billards:Loader3D = new Loader3D();
			_billards.scale(200);
			_billards.loadData(new BillardsModel(), billardsLoaderContent, null, new OBJParser(1));
			_billards.rotationY = 180;
			_billards.y = -400;
			_billards.x = -2800;
			_billards.z = 600;
			_view.scene.addChild(_billards);
			
			// set chairs up
			for (var yy:int = 0; yy < 8; yy++) {
				var barstoolLoaderContent:AssetLoaderContext = new AssetLoaderContext();
				barstoolLoaderContent.mapUrlToData(""barstool.mtl"", new BarStoolMTL());
				barstoolLoaderContent.mapUrlToData(""barstool.jpg"", new BarStoolTexture());
				var _stool:Loader3D = new Loader3D();
				_stool.scale(140);
				_stool.loadData(new BarStoolModel(), barstoolLoaderContent, null, new OBJParser(1));
				_stool.y = -400;
				_stool.x = 2400;
				_stool.z = -(450*4) + 450 * yy;
				_view.scene.addChild(_stool);
			}
			
			// make tables
			for (var yy:int = 0; yy < 4; yy++) {
				var counterLoaderContent:AssetLoaderContext = new AssetLoaderContext();
				counterLoaderContent.mapUrlToData(""counter.mtl"", new CounterMTL());
				counterLoaderContent.mapUrlToData(""counter.jpg"", new CounterTexture());
				var _counter:Loader3D = new Loader3D();
				_counter.scale(226);
				_counter.loadData(new CounterModel(), counterLoaderContent, null, new OBJParser(1));
				_counter.rotationY = 90;
				_counter.y = -400;
				_counter.x = 2900;
				_counter.z = -(900*1.55) + 900 * yy;
				_view.scene.addChild(_counter);
			}
			
		}
		
		private function loadTextureMaterials():void {
			gameWoodFloorTexture = new TextureMaterial(Cast.bitmapTexture(GrassDiffuse));
			gameWinFloorTexture = new TextureMaterial(Cast.bitmapTexture(FloorWin));
			gameBoxDiffuse = new TextureMaterial(Cast.bitmapTexture(FloorDiffuse));
		}
		
		private function loadQueues():void {
			for (var i:int = 0; i < 200; i++) {
				var floor:Mesh = new Mesh(new PlaneGeometry(200, 200, 1, 1), null);
				floor.x = floor.y = floor.z = faraway;
				floorQueue.push(floor);
			}
			for (var i:int = 0; i < 200; i++) {
				var box:Mesh = new Mesh(new CubeGeometry(200, 200, 200, 1, 1, 1), null);
				box.x = box.y = box.z = faraway;
				boxQueue.push(box);
			}
			
			for (var ii:int = 0; ii < 12; ii++) {
			for (var i:int = 0; i < 3; i++) {
				var coinLoaderContent:AssetLoaderContext = new AssetLoaderContext();
				coinLoaderContent.mapUrlToData(""coin.mtl"", new CoinMTL());
				var scaleMultiplier:Number;
				switch (i) {
					case 0:
						coinLoaderContent.mapUrlToData(""coingold.jpg"", new CoinGoldTexture());
						scaleMultiplier = 1.0;
					break;
					case 1:
						coinLoaderContent.mapUrlToData(""coingold.jpg"", new CoinSilverTexture());
						scaleMultiplier = 0.9;
					break;
					case 2:
						coinLoaderContent.mapUrlToData(""coingold.jpg"", new CoinCopperTexture());
						scaleMultiplier = 0.6;
					break;
				}
				var _coin:Loader3D = new Loader3D();
				_coin.loadData(new CoinModel(), coinLoaderContent, null, new OBJParser(1));
				_coin.scale(45 * scaleMultiplier);
				_coin.y = 70;
				_coin.x = _coin.y = faraway;
				
				pickupQueueInactive[i].push(_coin);
			}
			}
			
			for (var i:int = 0; i < 3; i++) {
				var starLoaderContent:AssetLoaderContext = new AssetLoaderContext();
				starLoaderContent.mapUrlToData(""star.mtl"", new StarMTL());
				starLoaderContent.mapUrlToData(""star.png"", new StarTexture());
				
				var _star:Loader3D = new Loader3D();
				_star.loadData(new StarModel(), starLoaderContent, null, new OBJParser(1));
				_star.scale(60);
				_star.y = 70;
				_star.x = _star.z = faraway;
				pickupQueueInactive[3].push(_star);
			}
		}
		
		private function resetVariables():void {
			goal = goal_reset;
			endLevel = false;
			coins = 0;
			stars = 0;
			coinsCollected = [0, 0, 0];
		}
		
		private function preLevelSetup():void {
			resetVariables();
			if (hud!=null) hud.Reset();
			
			solidlist = new Array();
			goallist = new Array();
			animationlist = new Array();
			pickuplist = new Array();
			reloadMapData = new Array(); // data to be used for reloading a level, will look like: [player.x, player.y, moves, pickuip1.id, pickup1.x, pickup1.y, pickup2.id, ....]
			
			totalcoins = 0;
			
			while (floorQueueActive.length > 0) {
				var floor:Mesh = floorQueueActive.pop()
				_view.scene.removeChild(floor);
				floor.x = floor.y = floor.z = faraway;
				floorQueue.push(floor);
			}
			while (boxQueueActive.length > 0) {
				var box:Mesh = boxQueueActive.pop()
				_view.scene.removeChild(box);
				box.x = box.y = box.z = faraway;
				boxQueue.push(box);
			}
			for (var i:int = 0; i < 4; i++) {
				while (pickupQueue[i].length > 0) {
					var c:Loader3D = pickupQueue[i].pop();
					_view.scene.removeChild(c);
					pickupQueueInactive[i].push(c);
				}
			}
			
			world = new b2World(new b2Vec2(0, 0), false); /// try setting to true
			if (contactListener == null) {
				contactListener = new ContactListener();
				contactListener.eventDispatcher.addEventListener(ContactListener.MUG_HIT_BLOCK, onMugHitBlock);
			}
			
			world.SetContactListener(contactListener);
		}
		
		private function onMugHitBlock(e:Event):void {
			if (Global.sound) {
				var thud:IAudioSource;
				var velocity:Number = player.body.GetLinearVelocity().Length();
				if (velocity > 100) velocity = 100;
				if (velocity < 60) {
					//sound_thud2.resetPosition();
					var thud:IAudioSource = new GainFilter(sound_thud2, -3*(velocity / 100.0));
					//var thud_echo:IAudioSource = new EchoFilter(sound_thud2, 1.0, 0.5, 0.5);
				} else {
					//sound_thud.resetPosition();
					var thud:IAudioSource = new GainFilter(sound_thud, -3*(velocity / 100.0));
				}
				audioplayer.play(thud);
			}
		}
		
		private function loadLevel(lvl:int = 0):void {
			if (lvl == lastLevel) {
				restartLevel();
				return;
			}
			preLevelSetup();
			var levelData:XML;
			switch (lvl) {
				case 0: levelData = new XML(new Assets.Level1); break;
				case 1: levelData = new XML(new Assets.Level2); break;
				case 2: levelData = new XML(new Assets.Level3); break;
				case 3: levelData = new XML(new Assets.Level4); break;
				case 4: levelData = new XML(new Assets.Level5); break;
				case 5: levelData = new XML(new Assets.Level6); break;
				case 6: levelData = new XML(new Assets.Level7); break;
				case 7: levelData = new XML(new Assets.Level8); break;
				case 8: levelData = new XML(new Assets.Level9); break;
				case 9: levelData = new XML(new Assets.Level10); break;
				case 10: levelData = new XML(new Assets.Level11); break;
				case 11: levelData = new XML(new Assets.Level12); break;
				case 12: levelData = new XML(new Assets.Level13); break;
				case 13: levelData = new XML(new Assets.Level14); break;
				case 14: levelData = new XML(new Assets.Level15); break;
				case 15: levelData = new XML(new Assets.Level16); break;
				case 16: levelData = new XML(new Assets.Level17); break;
				case 17: levelData = new XML(new Assets.Level18); break;
				case 18: levelData = new XML(new Assets.Level19); break;
				case 19: levelData = new XML(new Assets.Level20); break;
				case 20: levelData = new XML(new Assets.Level21); break;
				case 21: levelData = new XML(new Assets.Level22); break;
				case 22: levelData = new XML(new Assets.Level23); break;
				case 23: levelData = new XML(new Assets.Level24); break;
			}
			if (lastLevel == 0 && hud != null) {
				hud.tutorial(-1);
			}
			lastLevel = currentLevel = lvl;
			
			tutorialmode = (currentLevel == 0 ? 0 : -1);
			
			// parse
			var o:XML;
			var w:int, h:int, d:int, segw:int, segh:int;
			
			
			for each (o in levelData.FLOOR[0].TILE) {
				var plane:Mesh = floorQueue.pop();
				switch (int(o.@tex)) {
					case 1: plane.material = gameWoodFloorTexture; break;
					case 2: plane.material = gameWinFloorTexture; break;
				}
				//plane.material = textureMaterial;
				plane.x = o.@x;
				plane.y = o.@y;
				plane.z = o.@z;
				floorQueueActive.push(plane);
			}
			for each (o in levelData.WALL[0].BLOCK)
			{
				//var textureMaterial:TextureMaterial;
				
				var box:Mesh = boxQueue.pop();
				switch (o.@tex) {
					case 1: box.material = gameBoxDiffuse; break;
					default: box.material = gameBoxDiffuse;
				}
				
				//box.material = textureMaterial;
				box.x = o.@x;
				box.y = o.@y;
				box.z = o.@z;
				boxQueueActive.push(box);
				
				var b2boxDef:b2BodyDef = new b2BodyDef();
				b2boxDef.type = b2Body.b2_staticBody;
				b2boxDef.position = new b2Vec2(box.x * worldScale, box.z * worldScale);
				var b2box:b2Body = world.CreateBody(b2boxDef);
				var fixtureDef:b2FixtureDef = new b2FixtureDef();
				fixtureDef.shape = b2PolygonShape.AsBox(100 * worldScale, 100 * worldScale);
				var fixture:b2Fixture = b2box.CreateFixture(fixtureDef);
				b2box.SetUserData(""block"");
				
				solidlist.push(new Rectangle(box.x-100, box.z-100, 200, 200));
			}
			for each (o in levelData.GOALS[0].GOAL)
			{
				var go:GeneralObject = new GeneralObject(o.@x, o.@z, o.@w, o.@h);
				goallist.push(go);
			}
			for each (o in levelData.COINS[0].COIN)
			{
				var id:int = o.@id;
				
				var _coin:Loader3D = pickupQueueInactive[id-1].pop();
				
				switch (id) {
					case 1:
						totalcoins += 25;
					break;
					case 2:
						totalcoins += 10;
					break;
					case 3:
						totalcoins++;
					break;
				}
				
				_coin.visible = true;
				_coin.y = 70;
				_coin.x = o.@x;
				_coin.z = o.@z;
				
				pickupQueue[id - 1].push(_coin);
				
				_view.scene.addChild(_coin);
				
				var _coinContainer:GeneralObject = new GeneralObject(o.@x, o.@z, 64, 64);
				_coinContainer.model = _coin;
				_coinContainer.id = id - 1;
				
				pickuplist.push(_coinContainer);
			}
			for each (o in levelData.STARS[0].STAR)
			{
				var _star:Loader3D = pickupQueueInactive[3].pop();
				_star.y = 70;
				_star.x = o.@x;
				_star.z = o.@z;
				
				_star.visible = true;
				
				pickupQueue[3].push(_star);
				_view.scene.addChild(_star);
				
				var _starContainer:GeneralObject = new GeneralObject(o.@x, o.@z, 64, 64);
				_starContainer.model = _star;
				_starContainer.id = 3;
				
				pickuplist.push(_starContainer);
			}
			
			//if (player.body==null) {
			var b2mugDef:b2BodyDef = new b2BodyDef();
			b2mugDef.type = b2Body.b2_dynamicBody;
			b2mugDef.awake = true;
			b2mugDef.inertiaScale = 0.5;
			b2mugDef.angularDamping = 2.0;
			b2mugDef.position = new b2Vec2(player.x * worldScale,player.y * worldScale);
			var b2mug:b2Body = world.CreateBody(b2mugDef);
			var fixtureDef:b2FixtureDef = new b2FixtureDef();
			fixtureDef.shape = new b2CircleShape(player.w / 2 * worldScale);
			fixtureDef.restitution = 0.8;
			fixtureDef.density = 0.1;
			var fixture:b2Fixture = b2mug.CreateFixture(fixtureDef);
			
			b2mug.SetLinearDamping(1.1);
			b2mug.SetUserData(""mug"");
			player.body = b2mug;
			//}
			
			for (var i:int = 0; i < floorQueueActive.length; i++) {
				_view.scene.addChild(floorQueueActive[i]);
			}
			for (var i:int = 0; i < boxQueueActive.length; i++) {
				_view.scene.addChild(boxQueueActive[i]);
			}
			
			for each (o in levelData.PROPERTIES) {
				if (o.hasOwnProperty(""@moves"")) {
					player.moves = o.@moves;
				}
				if (o.hasOwnProperty(""@px"") && o.hasOwnProperty(""@py"")) {
					player.body.SetPosition(new b2Vec2(int(o.@px) * worldScale, int(o.@py)* worldScale));
				}
			}
			
			reloadMapData = [player.body.GetPosition().x, player.body.GetPosition().y, player.moves];
			
			for (var i:int = 0; i < pickuplist.length; i++) {
				reloadMapData.push(pickuplist[i].id);
				reloadMapData.push(pickuplist[i].x);
				reloadMapData.push(pickuplist[i].y);
			}
			
			cameraDisplacementMag = 0;
			previewCourse = false;
			
			setuphud = true;
			
			
			/*
			// collision debug code
			for (var i:int = 0; i < 1000; i++) {
				var box:Mesh = new Mesh(new CubeGeometry(4, 4, 4, 1, 1, 1));
				var good:Boolean = false;
				var x:int, y:int;
				do {
					x = -2000 + Math.random() * 4000;
					y = -1600 + Math.random() * 3200;
					good = collideWithSolids(new Rectangle(x, y, 4, 4));
				} while (!good);
				box.x = x;
				box.z = y;
				box.y = 24;
				_view.scene.addChild(box);
			}*/
			
		}
		
		private function restartLevel():void {
			var next:Array = [0, 0, 0, 0];
			pickuplist = new Array();
			player.body.SetPosition(new b2Vec2(reloadMapData[0], reloadMapData[1]));
			player.body.SetLinearVelocity(new b2Vec2(0, 0));
			player.moves = reloadMapData[2];
			if (hud!=null) {hud.Reset();}
			
			while (animationlist.length > 0) {
				var ani:AnimationContainer = animationlist.pop();
				if (ani.model!=null) {
					ani.model.rotationX = 0;
					ani.model.rotationZ = 0;
					ani.model = null;
				}
				//pickupQueue[ani.id].push(ani.model);
			}
			
			var id:int, size:int = 64;
			for (var i:int = 3; i < reloadMapData.length; i+=3) {
				id = int(reloadMapData[i]);
				//size = (id == 3 ? 56 : 48);
				var g:GeneralObject = new GeneralObject(reloadMapData[i+1], reloadMapData[i+2], size, size);
				g.id = id;
				g.model = pickupQueue[id][next[id]];
				next[id]++;
				g.model.visible = true;
				g.model.x = g.x;
				g.model.z = g.y;
				g.model.y = 70;
				if (hud!=null) {hud.add_coin(g.x, g.y, g.id);}
				pickuplist.push(g);
			}
			
			resetVariables();
			
			if (currentLevel == 0) {
				tutorialmode = 0;
				if (hud!=null) {hud.tutorial(0);}
			}
			
			restart = false;
		}
		
		private function init(e:Event):void {
			if (hasEventListener(Event.ADDED_TO_STAGE)) {
				removeEventListener(Event.ADDED_TO_STAGE, init);
			}
			sharedOBJ = SharedObject.getLocal(""rbslider_saved"");
			// Setup for handling Away3D and Starling Interoperation
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			
			Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT;
			
			initProxies();
			
		}
		
		private function initProxies():void {
			// Code from starling/away3d interoperability example
			// Define a new Stage3DManager for the Stage3D objects
			stage3DManager = Stage3DManager.getInstance(stage);
			
			// Create a new Stage3D proxy to contain the separate views
			stage3DProxy = stage3DManager.getFreeStage3DProxy();
			stage3DProxy.addEventListener(Stage3DEvent.CONTEXT3D_CREATED, onContextCreated);
			stage3DProxy.antiAlias = 2;
			stage3DProxy.color = 0x0;
		}
		
		private function onContextCreated(event:Stage3DEvent):void {
			//Tweener.init(); // The Tweener library is fantastic but not used in this project
			if (checkDomain("""")) {
				initAway3D();
				initStarling();
				initAway3DScene();
				// Used for site locking:
				//if (stage.loaderInfo.url.indexOf(""codeinferno.com"")!=-1) {
					initListeners();
				//}
				onResize();
			}
		}
		
		public function checkDomain (allowed:*):Boolean
		{
			var url:String = stage.loaderInfo.url;
			var startCheck:int = url.indexOf('://' ) + 3;

			if (url.substr(0, startCheck) == 'file://') return true;

			var domainLen:int = url.indexOf('/', startCheck) - startCheck;
			var host:String = url.substr(startCheck, domainLen);

			if (allowed is String) allowed = [allowed];
			for each (var d:String in allowed)
			{
				if (host.substr(-d.length, d.length) == d) return true;
			}

			return false;
		}
		
		private function initAway3D() : void
		{
			_view = new View3D();
			_view.stage3DProxy = stage3DProxy;
			_view.shareContext = true;
			
			addChild(_view);
		}
		
		private function initAway3DScene() : void
		{
			//setup the camera
			_view.camera.x = 0;
			_view.camera.z = -400;
			_view.camera.y = 1000;
			_view.camera.lookAt(new Vector3D());
			
			//setup the scene
			var mugLoaderContent:AssetLoaderContext = new AssetLoaderContext();
			mugLoaderContent.mapUrlToData(""mug.mtl"", new MugMTL());
			mugLoaderContent.mapUrlToData(""mug.jpg"", new MugTexture());
			
			_mug = new Loader3D();
			_mug.name = ""mug"";
			_mug.scale(75);
			_mug.loadData(new MugModel(), mugLoaderContent, null, new OBJParser(1));
			_mug.y = 10;
			
			_view.scene.addChild(_mug);
			
			player = new Player();
			
			load();
			loadTextureMaterials();
			loadSounds();
			loadQueues();
			SetupScene();
			
			loadLevel(0);
			
			musicchannel.soundTransform = new SoundTransform(Global.music ? 1 : 0);
		}
		/**
		 * Initialise the Starling sprites
		 */
		private function initStarling() : void
		{
			// Create the Starling scenes
			//starlingBackground = new Starling(StarlingBackground, stage, stage3DProxy.viewPort, stage3DProxy.stage3D);
			Starling.handleLostContext = true;
			
			starlingForeground = new Starling(StarlingForeground, stage, stage3DProxy.viewPort, stage3DProxy.stage3D);
			starlingForeground.antiAliasing = 2;
			
			starlingForeground.start();
		}
		
		
		private function initListeners():void {
			//stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);
			stage.addEventListener(Event.ENTER_FRAME, _onEnterFrame, false,0, true);
			//stage.addEventListener(Event.RESIZE, onResize);
			_view.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown, false,0, true);
			_view.addEventListener(MouseEvent.MOUSE_UP, onMouseUp, false,0, true);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyboardDown, false,0, true);
			stage.addEventListener(KeyboardEvent.KEY_UP, onKeyboardUp, false,0, true);
			//stage.addEventListener(Event.ACTIVATE, onActivate);
			stage.addEventListener(Event.DEACTIVATE, onDeactivate, false,0, true);
		}
		
		
		/**
		 * Main render loop
		 */
		private function _onEnterFrame(e:Event):void
		{
			if (Global.music!=music_updated) {
				musicchannel.soundTransform = new SoundTransform(Global.music ? 1 : 0);
				music_updated = Global.music;
			}
			
			if (play_sound_button) {
				if (Global.sound) {
					sound_button.resetPosition();
					audioplayer.play(sound_button);
				}
				play_sound_button = false;
			}
			
			/// Game logic
			if (room==2) {
				updateInGame();
				
			} else if (room == 0 || !enteredLevel) {
				if (pickupQueue.length > 0) {
					if (pickupQueue[0][0].visible) {
						for (var i:int = 0; i < 4; i++) {
							for (var ii:int = 0; ii < pickupQueue[i].length; ii++) {
								pickupQueue[i][ii].visible = false;
							}
						}
					}
				}
				title_pan_cam += 0.001;
				if (title_pan_cam > 2) title_pan_cam -= 2;
				_view.camera.x = -2000 + (title_pan_cam < 1 ? title_pan_cam : (2-title_pan_cam)) * 4300;
				_view.camera.z = 1500 - ((title_pan_cam < 1 ? 0 : (title_pan_cam < 1.5? title_pan_cam-1 : 2-title_pan_cam)) * 4000);
				
			} else if (room == 1) {
				title_pan_cam = 0;
			}
			
			/// Render logic
			stage3DProxy.clear(); // Clear the Context3D object
			
			//starlingBackground.nextFrame();
			
			if (_view!=null) {_view.render();}
			
			starlingForeground.nextFrame();
			
			stage3DProxy.present(); // Present the Context3D object to Stage3D
		}
		
		private function updateHudBlocks():void {
			if (hud != null) {
				hud.clear_blocks();
				var i:int;
				for (var i = 0; i < solidlist.length; i++) {
					hud.add_block(solidlist[i].x+100, solidlist[i].y+100);
				}
				for (var i = 0; i < goallist.length; i++) {
					hud.add_floor(goallist[i].x, goallist[i].y, 1);
				}
				for (var i = 0; i < floorQueueActive.length; i++) {
					hud.add_floor(floorQueueActive[i].x, floorQueueActive[i].z, 0);
				}
			}
		}
		/**
		 * Game logic loop
		 */
		private function updateInGame():void {
			if (!enteredLevel) enteredLevel = true;
			if (hud != null) {
				hud.update();
				hud.update_player(player.x, player.y);
				hud.update_stats(player.moves);
			}
			
			if (restart) {
				restartLevel();
			}
			if (_setLevel != -1) {
				if (Global.sound) {
					sound_soda.resetPosition();
					audioplayer.play(sound_soda);
				}
				loadLevel(_setLevel);
				_setLevel = -1;
				return;
			}
			if (tutorialmode!=-1 && hud!=null) {
				switch (tutorialmode) {
					case 0:
						hud.tutorial(0);
						tutorialmode = 1;
					break;
					case 1:
						if (player.body.GetLinearVelocity().Length() > 15) {
							if (hud != null) { hud.tutorial(1); }
							tutorialmode = 2;
						}
					break;
					case 2:
						if (inGoal) {
							if (hud != null) { hud.tutorial(2); }
							tutorialmode = 3;
						}
					break;
				}
			}
			
			if (play_sound_coindrop) {
				if (Global.sound) {
					sound_coindrop.resetPosition();
					audioplayer.play(sound_coindrop);
				}
				play_sound_coindrop = false;
			}
			
			if (room != 2) return;
			
			if (endLevel) {
				if (player.drag) {
					player.drag = false;
				}
			} else if (Global.pause) {
				world.Step(0, 3, 3);
				
				return;
			}
			
			//_plane.rotationY += 1;
			player.update();
			//crosshair.update();
			world.Step(1.0/60.0, 3, 3);
			
			if (goal > 0) {
				inGoal = false;
				if (!player.drag && player.body.GetLinearVelocity().Length() < 4) {
					for (var i:int = 0; i < goallist.length; i++) {
						if ((new Rectangle(player.x - player.w / 2, player.y - player.h / 2, player.w, player.h)).intersects(new Rectangle(goallist[i].x - goallist[i].w / 2, goallist[i].y - goallist[i].h / 2, goallist[i].w, goallist[i].h))) {
							inGoal = true;
						}
					}
				}
				if (!inGoal) {
					goal = goal_reset;
					if (hud!=null) hud.HideSpinloader();
				} else {
					if (hud != null) hud.Spinloader(goal);
					if (Global.sound) {
						switch (goal) {
							case 90:
							case 60:
							case 30:
							case 1:
								sound_countdown.resetPosition();
								audioplayer2.play(sound_countdown);
							break;
						}
					}
					goal--;
					if (goal <= 0) {
						hud.endLevel(player.moves, stars, coins, totalcoins, coinsCollected[0], coinsCollected[1], coinsCollected[2]);
						hud.HideSpinloader();
						endLevel = true;
					}
				}
			}
			if (player.moves < 1 && !endLevel && goal==goal_reset && player.body.GetLinearVelocity().Length() < 1) {
				endLevel = true;
				hud.createLoseMenu();
			}
			
			for (var i:int = 0; i < pickuplist.length; i++) {
				(pickuplist[i] as GeneralObject).update();
				if (pickuplist[i].id >= 0 && pickuplist[i].id < 12) {
					if (!player.drag && (new Rectangle(player.x - player.w / 2, player.y - player.h / 2, player.w, player.h)).intersects(new Rectangle(pickuplist[i].x - pickuplist[i].w / 2, pickuplist[i].y - pickuplist[i].h / 2, pickuplist[i].w, pickuplist[i].h))) {
						removeCoin(i);
						pickuplist.splice(i, 1);
						i--;
					}
				}
			}
			for (var i:int = 0; i < animationlist.length; i++) {
				animationlist[i].update();
				if (animationlist[i].life <= 0) {
					if (animationlist[i].model!=null) {
						animationlist[i].model.rotationX = 0;
						animationlist[i].model.rotationZ = 0;
						animationlist[i].model.visible = false;
					}
					animationlist[i].model = null;
					animationlist.splice(i, 1);
					i--;
					//trace(""yes"");
				}
			}
			
			globalMouseX = mouseX;
			globalMouseY = mouseY;
			if (keySpace) {
				mouseAccelY = lerp(mouseAccelY, (mouseY - 240) * 4, 0.2);
				mouseAccelX = lerp(mouseAccelX, (mouseX - 320) * 4, 0.2);
			} else {
				mouseAccelX = lerp(mouseAccelX, 0, 0.4);
				mouseAccelY = lerp(mouseAccelY, 0, 0.4);
			}
			_mug.x = player.x;
			_mug.z = player.y;
			_mug.rotationY = player.rotation + 180;
			
			if (cameraDisplacementMag > 0) {
				_view.camera.z = player.y -300+ cameraDisplacementMag * cameraDirection;// - mouseAccelY;
				_view.camera.x = player.x + cameraDisplacementMag * cameraDirection;// + mouseAccelX;
			} else {
				_view.camera.z = player.y-360- mouseAccelY;
				_view.camera.x = player.x + mouseAccelX;
			}
			manageHud();
		}
		
		private function manageHud():void {
			if (hud == null) {
				if (StarlingForeground.hud != null) hud = StarlingForeground.hud;
				else return;
			}
			if (!hud.added) return;
			
			if (setuphud) {
				for (var index:int = 0; index < pickuplist.length; index++) {
					hud.add_coin(pickuplist[index].x, pickuplist[index].y, pickuplist[index].id);
					
				}
				hud.finalize_coins();
				hud.setCoins(totalcoins);
				
				updateHudBlocks();
				
				hud.update_player(player.x, player.y);
				hud.update_stats(player.moves);
				setuphud = false;
			}
		}
		
		private function removeCoin(index:int):void {
			if (hud != null) {
				if (pickuplist[index].id == 3) {
					hud.getStar();
					stars++;
				} else {
					switch (pickuplist[index].id) {
						case 0: hud.getCoin(25); break;
						case 1: hud.getCoin(10); break;
						case 2: hud.getCoin(1); break;
					}
				}
				hud.remove_coin(pickuplist[index].x, pickuplist[index].y);
			}
			
			if (pickuplist[index].id == 3) {
				if (Global.sound) {
					sound_star.resetPosition();
					var sound_star_resample:IAudioSource = new ResamplingFilter(sound_star, 1.1+(stars-1)/9);
					audioplayer2.play(sound_star_resample);
				}
			} else {
				switch (pickuplist[index].id) {
					case 0: coins += 25; coinsCollected[0]++; break;
					case 1: coins += 10; coinsCollected[1]++; break;
					case 2: coins++; coinsCollected[2]++; break;
				}
				if (Global.sound) {
					sound_coin.resetPosition();
					audioplayer.play(sound_coin);
				}
			}
			
			
			animationlist.push(new AnimationContainer((pickuplist[index].id == 3 ? 1 : 0), pickuplist[index].model));
			pickuplist[index].model = null;
		}
		
		private function collideWithSolids(collisionBox:Rectangle):Boolean {
			for (var i:int = 0; i < solidlist.length; i++) if (collisionBox.intersects(solidlist[i])) return true;
			return false;
		}
		
		
		private function lerp(val1:int, val2:int, amount:Number):int {
			return val1 + ((val2 - val1) * amount)
		}
		
		/**
		 * stage listener for resize events
		 */
		private function onResize(event:Event = null):void
		{
			_view.width = stage.stageWidth;
			_view.height = stage.stageHeight;
		}
		
		private function mouseUp():void {
			if (room == 2 && !endLevel) {
				if (player.drag) {
					player.drag = false;
				}
			}
		}
		
		
		private function onDeactivate(e:Event):void {
			if (room == 2 && !endLevel) {
				Global.pause = true;
			}
		}
		
		//private function onActivate(e:Event):void {
			//Global.pause = false;
		//}
		private function onMouseUp(e:MouseEvent):void {
			mouseUp();
		}
		
		private function onMouseUpOutside(e:MouseEvent):void {
			mouseUp();
			e.target.removeEventListener( MouseEvent.MOUSE_UP, onMouseUpOutside );
		}
		
		private function onMouseDown(e:MouseEvent):void {
			if (room == 2 && !endLevel) {
				if (player.moves>0) {
					//fireRocket(_turtlegun.rotationY);
					if (previewCourse) {
						previewCourse = false;
					}
					
					if (Global.pause) return;
					
					if (!player.drag && !keySpace && !(new Rectangle(0, 480-54, 154, 54)).containsPoint(new Point(mouseX,mouseY))) {
						player.xstart = player.x;
						player.ystart = player.y;
						player.mousexstart = mouseX;
						player.mouseystart = mouseY;
						player.drag = true;
					}
				} else {
					player.body.SetLinearVelocity(new b2Vec2(0, 0));
				}
			}
			e.target.stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUpOutside);
		}
		
		private function onKeyboardDown(e:KeyboardEvent):void {
			switch (e.keyCode) {
				case 32: keySpace = true; break;
			}
		}
		
		private function onKeyboardUp(e:KeyboardEvent):void {
			switch (e.keyCode) {
				case 32: keySpace = false; break;
			}
		}
		
		function loadSounds():void {
			audioplayer = new AudioPlayer();
			audioplayer2 = new AudioPlayer();
			sound_soda = new SoundSource(new Assets.Sound_Sodagun() as Sound);
			sound_coin = new SoundSource(new Assets.Sound_Coin() as Sound);
			sound_thud = new SoundSource(new Assets.Sound_Thud() as Sound);
			sound_thud2 = new SoundSource(new Assets.Sound_Thud2() as Sound);
			sound_coindrop = new SoundSource(new Assets.Sound_Coindrop() as Sound);
			sound_star = new SoundSource(new Assets.Sound_Star() as Sound);
			sound_countdown = new SoundSource(new Assets.Sound_Countdown() as Sound);
			sound_button = new SoundSource(new Assets.Sound_Button() as Sound);
			music = (new Assets.Music() as Sound);
			musicchannel = music.play(0, 999999);
			musicchannel.soundTransform = new SoundTransform(0);
		}
		
		static public function resetsave():void {
			var gameData:XML = <sav>
								</sav>;
			for (var i:int = 0; i < Global.stars.length; i++) {
				var recordXML:XML = <str />
				recordXML.@str = 0;
				gameData.appendChild(recordXML);
			}
			for (var i:int = 0; i < Global.coins.length; i++) {
				var recordXML:XML = <cns />
				recordXML.@cns = 0;
				gameData.appendChild(recordXML);
			}
			
			sharedOBJ.data.gameXML = gameData;
			sharedOBJ.flush();
		}
		
		static public function save():void {
			var gameData:XML = <sav>
								</sav>;
			for (var i:int = 0; i < Global.stars.length; i++) {
				var recordXML:XML = <str />
				recordXML.@str = Global.stars[i];
				gameData.appendChild(recordXML);
			}
			for (var i:int = 0; i < Global.coins.length; i++) {
				var recordXML:XML = <cns />
				recordXML.@cns = Global.coins[i];
				gameData.appendChild(recordXML);
			}
			
			sharedOBJ.data.gameXML = gameData;
			sharedOBJ.flush();
		}
		
		static public function load():void {
			var counter:int = 0;
			if (sharedOBJ.data.gameXML != undefined) {
				var xml:XML = sharedOBJ.data.gameXML;
				
				for each (var recordXML:XML in xml.str) {
					if (counter < Global.stars.length) {
						Global.stars[counter] = recordXML.@str;
						counter++;
					}
				}
				counter = 0;
				for each (var recordXML:XML in xml.cns) {
					if (counter < Global.coins.length) {
						Global.coins[counter] = recordXML.@cns;
						counter++;
					}
				}
			}
		}
	}
}
",12335,False,1988.1922769177943,median
"package com.mcleodgaming.as3js.parser
{
	import com.mcleodgaming.as3js.Main;
	import com.mcleodgaming.as3js.enums.*;
	import com.mcleodgaming.as3js.types.*;
	require ""path""
	require ""fs""
	
	public class AS3Parser 
	{
		/**
		 * Keeps track of previous function name to assist extractBlock() debugging
		 * TODO: This could definitely be implemented better
		 */
		public static var PREVIOUS_BLOCK:String;
		
		//public var index:int;
		public var stack:Array;
		public var src:String;
		public var classPath:String;
		public var parserOptions:Object;
			
		public function AS3Parser(src:String, classPath:String = null):void 
		{
			//index = 0;
			stack = [];
			this.src = src;
			this.classPath = classPath;
			parserOptions = { };
			parserOptions.safeRequire = false;
			parserOptions.ignoreFlash = false;
		}
		
		public static function increaseIndent(str:String, indent:String):String
		{
			return (indent + str).replace(/\\n/g, ""\\n"" + indent);
		}
		public static function parseArguments(str:String):Array
		{
			var args:Vector.<AS3Argument> = new Vector.<AS3Argument>();
			var tmpToken:AS3Token;
			var tmpArr:Array = AS3Parser.extractBlock(str, 0, '(', ')');
			var tmpExtractArr:Array = null;
			var index:int = tmpArr[1] - 1; //Ending index of parsed block
			var tmpStr:String = tmpArr[0].trim(); //Parsed block
			tmpStr = tmpStr.substr(1, tmpStr.length - 2); //Remove outer parentheses
			tmpArr = null; //Trash this
			tmpArr = tmpStr.split(','); //Split args by commas
			//Don't bother if there are no arguments
			if (tmpArr.length > 0 && tmpArr[0] != '')
			{
				//Truncate spaces and assign values to arguments as needed
				for (var i = 0; i < tmpArr.length; i++)
				{
					tmpStr = tmpArr[i].trim();
					args.push(new AS3Argument());
					if (tmpStr.indexOf('...') === 0)
					{
						//This is a ...rest argument, stop here
						args[args.length-1].name = tmpStr.substr(3);
						args[args.length-1].isRestParam = true;
						Main.debug('----->Parsed a ...rest param: ' + args[args.length-1].name);
						break;
					} else
					{
						//Grab the function name
						tmpToken = AS3Parser.nextWord(tmpStr, 0, AS3Pattern.VARIABLE[0], AS3Pattern.VARIABLE[1]); //Parse out the function name
						args[args.length-1].name = tmpToken.token; //Set the argument name
						Main.debug('----->Sub-Function argument found: ' + tmpToken.token);
						//If a colon was next, we'll assume it was typed and grab it
						if (tmpToken.index < tmpStr.length && tmpStr.charAt(tmpToken.index) == ':')
						{
							tmpToken = AS3Parser.nextWord(tmpStr, tmpToken.index, AS3Pattern.VARIABLE_TYPE[0], AS3Pattern.VARIABLE_TYPE[1]); //Parse out the argument type
							args[args.length-1].type = tmpToken.token; //Set the argument type
							Main.debug('----->Sub-Function argument typed to: ' + tmpToken.token);
						}
						tmpToken = AS3Parser.nextWord(tmpStr, tmpToken.index, AS3Pattern.ASSIGN_START[0], AS3Pattern.ASSIGN_START[1]);
						if (tmpToken.token == ""="")
						{
							//Use all characters after self symbol to set value
							tmpExtractArr = AS3Parser.extractUpTo(tmpStr, tmpToken.index, /[;\\r\\n]/g);
							//Store value
							args[args.length-1].value =  tmpExtractArr[0].trim();
							//Store value
							Main.debug('----->Sub-Function argument defaulted to: ' + tmpExtractArr[0].trim());
						}
					}
				}
			}
			return args;
		}
		public static function checkForCommentOpen(str:String):String
		{
			return (str == ""//"") ? AS3ParseState.COMMENT_INLINE : (str == ""/*"") ? AS3ParseState.COMMENT_MULTILINE : null;
		}
		public static function checkForCommentClose(state, str):Boolean
		{
			return (state == AS3ParseState.COMMENT_INLINE && (str.charAt(0) == '\\n' || str.charAt(0) == '\\r' || str.charAt(0) == '')) ? true : (state == AS3ParseState.COMMENT_MULTILINE && str == ""*/"") ? true : false; 
		}
		public static function checkForStringOpen(str:String):String
		{
			return (str == '""') ? AS3ParseState.STRING_DOUBLE_QUOTE : (str == ""'"") ? AS3ParseState.STRING_SINGLE_QUOTE : null;
		}
		public static function checkForStringClose(state, str):Boolean
		{
			return (state == AS3ParseState.STRING_DOUBLE_QUOTE && str == '""') ? true : (state == AS3ParseState.STRING_SINGLE_QUOTE && str == ""'"") ? true : false; 
		}
		public static function nextWord(src:String, index:int, characters:String, pattern:String):AS3Token
		{
			characters = characters || AS3Pattern.IDENTIFIER[0];
			pattern = pattern || AS3Pattern.IDENTIFIER[1];
			var tokenBuffer:String = null;
			var extraBuffer:String = ''; //Contains characters that were missed
			var escapeToggle:Boolean = false;
			var innerState:String = null;
			for (; index < src.length; index++)
			{
				var c = src.charAt(index);
				if (c.match(characters))
				{
					tokenBuffer = (tokenBuffer) ? tokenBuffer + c : c; //Create new token buffer if needed, otherwise append
				} else if (!innerState && AS3Parser.checkForCommentOpen(src.substr(index, 2)) && !tokenBuffer)
				{
					tokenBuffer = null;
					Main.debug(""Entering comment..."");
					innerState = AS3Parser.checkForCommentOpen(src.substr(index, 2));
					extraBuffer += src.substr(index, 2);
					index += 2; //Skip next index
					//Loop until we break out of comment
					for (; index < src.length; index++)
					{
						if (AS3Parser.checkForCommentClose(innerState, src.substr(index, 2)))
						{
							if (innerState == AS3ParseState.COMMENT_MULTILINE)
							{
								extraBuffer += src.substr(index, 2);
								index++; //Skip next token
							} else
							{
								extraBuffer += src.charAt(index);
							}
							innerState = null; //Return to previous state
							Main.debug(""Exiting comment..."");
							break;
						} else
						{
							extraBuffer += src.charAt(index);
						}
					}
				}  else if (!innerState && AS3Parser.checkForStringOpen(src.charAt(index)) && !tokenBuffer)
				{
					tokenBuffer = null;
					Main.debug(""Entering string..."");
					innerState = AS3Parser.checkForStringOpen(src.charAt(index));
					extraBuffer += src.substr(index, 1);
					index++; //Skip to next index
					//Loop until we break out of string
					for (; index < src.length; index++)
					{
						extraBuffer += src.charAt(index);
						if (!escapeToggle && src.charAt(index) == '\\\\')
						{
							escapeToggle = true;
							continue;
						}
						escapeToggle = false;
						if (AS3Parser.checkForStringClose(innerState, src.charAt(index)))
						{
							innerState = null; //Return to previous state
							Main.debug(""Exiting string..."");
							break;
						}
					}
				} else if (tokenBuffer && tokenBuffer.match(pattern))
				{
					return new AS3Token(tokenBuffer, index, extraBuffer); //[Token, Index]
				} else
				{
					if (tokenBuffer)
					{
						extraBuffer += tokenBuffer + c;
					} else 
					{
						extraBuffer += c;
					}
					tokenBuffer = null;
				}
			}
			return new AS3Token(tokenBuffer || null, index, extraBuffer); //[Token, Index]
		}
		public static function extractBlock(text:String, start:int = 0, opening:String = ""{"", closing:String = ""}""):Array
		{
			var buffer:String = """";
			var i:int = start;
			var count:int = 0;
			var started:Boolean = false;
			var insideString:String = null;
			var insideComment:String = null;
			var escapingChar:Boolean = false;
			while (!(count == 0 && started) && i < text.length)
			{
				if (insideComment)
				{
					//Inside of a comment, wait until we get out
					if (insideComment == '//' && (text.charAt(i) == '\\n' || text.charAt(i) == '\\r'))
					{
						insideComment = null; //End inline comment
						Main.debug(""Exited comment"");
					} else if (insideComment == '/*' && text.charAt(i) == '*' && i + 1 < text.length && text.charAt(i + 1) == '/')
					{
						insideComment = null; //End multiline comment
						Main.debug(""Exited comment"");
					}
				} else if (insideString)
				{
					//Inside of a string, wait until we get out
					if (!escapingChar && text.charAt(i) == ""\\\\"")
					{
						escapingChar = true; //Start escape sequence
					} else if (!escapingChar && text.charAt(i) == insideString)
					{
						insideString = null; //Found closing quote
					} else
					{
						escapingChar = false; //Forget escape sequence
					}
				} else if (text.charAt(i) == opening)
				{
					started = true;
					count++; //Found opening
				} else if (text.charAt(i) == closing)
				{
					count--; //Found closing
				} else if ((text.charAt(i) == '\\""' || text.charAt(i) == '\\''))
				{
					insideString = text.charAt(i); //Now inside of a string
				} else if (text.charAt(i) == '/' && i + 1 < text.length && text.charAt(i + 1) == '/')
				{
					Main.debug(""Entering comment... "" + ""(//)"");
					insideComment = '//';
				} else if (text.charAt(i) == '/' && i + 1 < text.length && text.charAt(i + 1) == '*')
				{
					Main.debug(""Entering comment..."" + ""(/*)"");
					insideComment = '/*';
				}
				if (started)
				{
					buffer += text.charAt(i);
				}
				i++;
			}
			if (!started)
			{
				throw new Error(""Error, no starting '"" + opening  + ""' found for method body while parsing "" + AS3Parser.PREVIOUS_BLOCK);
			} else if (count > 0)
			{
				throw new Error(""Error, no closing '"" + closing  + ""' found for method body while parsing "" + AS3Parser.PREVIOUS_BLOCK);
			} else if (count < 0)
			{
				throw new Error(""Error, malformed enclosing '"" + opening + closing + "" body while parsing "" + AS3Parser.PREVIOUS_BLOCK);
			}
			return [buffer, i];
		}
		public static function extractUpTo(text:String, start:int, target:String):Array
		{
			var buffer:String = """";
			var i:int = start;
			var insideString:String = null;
			var insideComment:String = null;
			var escapingChar:Boolean = false;
			var pattern:String = new RegExp(target);
			while (i < text.length)
			{
				if (insideComment)
				{
					//Inside of a comment, wait until we get out
					if (insideComment == '//' && (text.charAt(i) == '\\n' || text.charAt(i) == '\\r'))
					{
						insideComment = null; //End inline comment
						Main.debug(""Exited comment"");
					} else if (insideComment == '/*' && text.charAt(i) == '*' && i + 1 < text.length && text.charAt(i + 1) == '/')
					{
						insideComment = null; //End multiline comment
						Main.debug(""Exited comment"");
					}
				} else if (insideString)
				{
					//Inside of a string, wait until we get out
					if (!escapingChar && text.charAt(i) == ""\\\\"")
					{
						escapingChar = true; //Start escape sequence
					} else if (!escapingChar && text.charAt(i) == insideString)
					{
						insideString = null; //Found closing quote
					} else
					{
						escapingChar = false; //Forget escape sequence
					}
				} else if ((text.charAt(i) == '\\""' || text.charAt(i) == '\\''))
				{
					insideString = text.charAt(i); //Now inside of a string
				} else if (text.charAt(i) == '/' && i + 1 < text.length && text.charAt(i + 1) == '/')
				{
					Main.debug(""Entering comment... "" + ""(//)"");
					insideComment = '//';
				} else if (text.charAt(i) == '/' && i + 1 < text.length && text.charAt(i + 1) == '*')
				{
					Main.debug(""Entering comment..."" + ""(/*)"");
					insideComment = '/*';
				} else if (text.charAt(i).match(pattern))
				{
					break; //Done
				}
				buffer += text.charAt(i);
				i++;
			}
			return [buffer, i];
		}
		
		public static function fixClassPath(clsPath:String):String
		{
			// Class paths at the root level might accidentally be prepended with a "".""
			return clsPath.replace(/^\\./g, """");
		}
		public function getState():String
		{
			return (this.stack.length > 0) ? this.stack[this.stack.length - 1] : null;
		}
		private function parseHelper(cls:AS3Class, src:String):void
		{
			var i:*;
			var j:*;
			var c:String;
			var currToken:AS3Token = null;
			var tmpToken:AS3Token = null;
			var tmpStr:String = null;
			var tmpArr:Array = null;
			var currMember:AS3Member = null;
			var index:int;
			for (index = 0; index < src.length; index++)
			{
				c = src.charAt(index);
				if (getState() == AS3ParseState.START)
				{
					//String together letters only until we reach a non-letter
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
					index = currToken.index - 1; //Update to the new position
					if (currToken.token == 'package')
					{
						stack.push(AS3ParseState.PACKAGE_NAME);
					}
				} else if (getState() == AS3ParseState.PACKAGE_NAME)
				{
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.OBJECT[0], AS3Pattern.OBJECT[1]); //Package name
					tmpToken = AS3Parser.nextWord(src, index, AS3Pattern.CURLY_BRACE[0], AS3Pattern.CURLY_BRACE[1]); //Upcoming curly brace
					
					
					index = currToken.index - 1;
					if (!currToken.token || !tmpToken.token)
					{
						throw new Error(""Error parsing package name."");
					} else
					{
						if (tmpToken.index < currToken.index)
						{
							cls.packageName = ''; //Curly brace came before next token
							index = tmpToken.index;
						} else
						{
							cls.packageName = currToken.token; //Just grab the package name
						}
						Main.debug('Found package: ' + cls.packageName);
						cls.importWildcards.push(AS3Parser.fixClassPath(cls.packageName + '.*')); //Add wild card for its own folder
						stack.push(AS3ParseState.PACKAGE);
						Main.debug('Attempting to parse package...');
					}
				} else if (getState() == AS3ParseState.PACKAGE)
				{
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
					index = currToken.index - 1;
					if (currToken.token == 'class' || currToken.token == 'interface')
					{
						if(currToken.token == 'interface')
							cls.isInterface = true;
						stack.push(AS3ParseState.CLASS_NAME);
						Main.debug('Found class keyword...');
					} else if (currToken.token == 'import')
					{
						stack.push(AS3ParseState.IMPORT_PACKAGE);
						Main.debug('Found import keyword...');
					} else if (currToken.token == 'require')
					{
						stack.push(AS3ParseState.REQUIRE_MODULE);
						Main.debug('Found require keyword...');
					}
				} else if (getState() == AS3ParseState.CLASS_NAME)
				{
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
					tmpToken = AS3Parser.nextWord(src, index, AS3Pattern.CURLY_BRACE[0], AS3Pattern.CURLY_BRACE[1]);
					index = currToken.index;
					if (!currToken.token || !tmpToken.token)
					{
						throw new Error(""Error parsing class name."");
					} else if (tmpToken.index < currToken.index)
					{
						throw new Error(""Error, no class name found before curly brace."");
					} else
					{
						//Set the class name
						cls.className = currToken.token;
						
						// Update fully qualified class path if needed
						classPath = classPath || AS3Parser.fixClassPath(cls.packageName + '.' + cls.className); //Remove extra ""."" for top level packages
						
						cls.classMap[cls.className] = cls; //Register self into the import map (used for static detection)
						//Now we will check for parent class and any interfaces
						currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
						if (currToken.token == 'extends' && currToken.index < tmpToken.index)
						{
							index = currToken.index;
							currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
							index = currToken.index;
							//The token following 'extends' must be the parent class
							cls.parent = currToken.token;
							//Prep the next token
							currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
							Main.debug(""Found parent: "" + cls.parent);
						}
						if (currToken.token == 'implements' && currToken.index < tmpToken.index)
						{
							index = currToken.index;
							currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
							index = currToken.index;
							//The token following 'implements' must be an interface
							cls.interfaces.push(currToken.token);
							Main.debug(""Found interface: "" + currToken.token);
							currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
							//While we are at a token before the next curly brace
							while (currToken.index < tmpToken.index && currToken.index < src.length)
							{
								//Consider self token another interface being implemented
								index = currToken.index;
								Main.debug(""Found interface: "" + currToken.token);
								cls.interfaces.push(currToken.token);
								currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
								index = currToken.index;
							}
						}
						Main.debug('Parsed class name: ' + cls.className);
						//Now parsing inside of the class
						stack.push(AS3ParseState.CLASS);
						Main.debug('Attempting to parse class...');
						
						//Extract out the next method block
						AS3Parser.PREVIOUS_BLOCK = cls.className + "":Class"";
						tmpStr = AS3Parser.extractBlock(src, index)[0];
						index += tmpStr.length - 1;
						
						//Recursively call parseHelper again under this new state (Once returned, package will be exited)
						parseHelper(cls, tmpStr);
					}
				} else if (getState() == AS3ParseState.CLASS)
				{
					currMember = currMember || new AS3Member(); //Declare a new member to work with if it doesn't exist yet
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
					index = currToken.index - 1;
					if (currToken.token == AS3Encapsulation.PUBLIC || currToken.token == AS3Encapsulation.PRIVATE || currToken.token == AS3Encapsulation.PROTECTED)
					{
						currMember.encapsulation = currToken.token;
						Main.debug('->Member encapsulation set to ' + currMember.encapsulation);
					} else if (currToken.token == 'static')
					{
						currMember.isStatic = true;
						Main.debug('-->Static flag set');
					} else if (currToken.token == AS3MemberType.VAR || currToken.token == AS3MemberType.CONST)
					{
						Main.debug('--->Member type ""variable"" set.');
						currMember = currMember.createVariable(); //Transform the member into a variable
						stack.push(AS3ParseState.MEMBER_VARIABLE);
					} else if (currToken.token == AS3MemberType.FUNCTION)
					{
						currToken = AS3Parser.nextWord(src, index + 1, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
						//Check for getter/setter
						if ((currToken.token == 'get' || currToken.token == 'set') && src[index + 1 + currToken.token.length + 1] != '(')
						{
							Main.debug('--->Member sub-type ""' + currToken.token + '"" set.');
							currMember.subType = currToken.token;
							index = currToken.index - 1;
						}
						currMember = currMember.createFunction(); //Transform the member into a function
						stack.push(AS3ParseState.MEMBER_FUNCTION);
						Main.debug('---->Member type ""function"" set.');
					}
				} else if (getState() == AS3ParseState.MEMBER_VARIABLE)
				{
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
					currMember.name = currToken.token; //Set the member name
					Main.debug('---->Variable name declared: ' + currToken.token);
					index = currToken.index;
					if (src.charAt(index) == "":"")
					{
						currToken = AS3Parser.nextWord(src, index, AS3Pattern.VARIABLE_TYPE[0], AS3Pattern.VARIABLE_TYPE[1]);
						index = currToken.index;
						currMember.type = currToken.token;//Set the value type name
						Main.debug('---->Variable type for ' + currMember.name + ' declared as: ' + currToken.token);
					}
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.ASSIGN_START[0], AS3Pattern.ASSIGN_START[1]);
					if (currToken.token == ""="")
					{
						//Use all characters after self symbol to set value
						index = currToken.index;
						tmpArr = AS3Parser.extractUpTo(src, index, /[;\\r\\n]/g);
						//Store value
						currMember.value = tmpArr[0].trim();
						index =  tmpArr[1];
						
						cls.membersWithAssignments.push(currMember);
					}

					//Store and delete current member and exit
					if (currMember.isStatic)
					{
						cls.staticMembers.push(currMember);
					} else
					{
						cls.members.push(currMember);
					}
					cls.registerField(currMember.name, currMember);
					currMember = null;
					stack.pop();
				} else if (getState() == AS3ParseState.MEMBER_FUNCTION)
				{
					//Parse the arguments
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IDENTIFIER[0], AS3Pattern.IDENTIFIER[1]);
					index = currToken.index;
					currMember.name = currToken.token; //Set the member name
					Main.debug('****>Function name declared: ' + currToken.token);
					
					AS3Parser.PREVIOUS_BLOCK = currMember.name + "":Function"";
					tmpArr = AS3Parser.extractBlock(src, index, '(', ')');
					index = tmpArr[1] - 1; //Ending index of parsed block
					tmpStr = tmpArr[0].trim(); //Parsed block
					tmpStr = tmpStr.substr(1, tmpStr.length - 2); //Remove outer parentheses
					tmpArr = null; //Trash this
					tmpArr = tmpStr.split(','); //Split args by commas
					//Don't bother if there are no arguments
					if (tmpArr.length > 0 && tmpArr[0] != '')
					{
						//Truncate spaces and assign values to arguments as needed
						for (i = 0; i < tmpArr.length; i++)
						{
							tmpStr = tmpArr[i];
							//Grab the function name
							tmpToken = AS3Parser.nextWord(tmpStr, 0, AS3Pattern.VARIABLE[0], AS3Pattern.VARIABLE[1]); //Parse out the function name
							currMember.argList.push(new AS3Argument());
							if (tmpStr.indexOf('...') === 0)
							{
								//This is a ...rest argument, stop here
								currMember.argList[currMember.argList.length-1].name = tmpStr.substr(3);
								currMember.argList[currMember.argList.length-1].isRestParam = true;
								Main.debug('----->Parsed a ...rest param: ' + currMember.argList[currMember.argList.length-1].name);
								break;
							} else
							{
								currMember.argList[currMember.argList.length-1].name = tmpToken.token; //Set the argument name
								Main.debug('----->Function argument found: ' + tmpToken.token);
								//If a colon was next, we'll assume it was typed and grab it
								if (tmpToken.index < tmpStr.length && tmpStr.charAt(tmpToken.index) == ':')
								{
									tmpToken = AS3Parser.nextWord(tmpStr, tmpToken.index, AS3Pattern.VARIABLE_TYPE[0], AS3Pattern.VARIABLE_TYPE[1]); //Parse out the argument type
									currMember.argList[currMember.argList.length-1].type = tmpToken.token; //Set the argument type
									Main.debug('----->Function argument typed to: ' + tmpToken.token);
								}
								tmpToken = AS3Parser.nextWord(tmpStr, tmpToken.index, AS3Pattern.ASSIGN_START[0], AS3Pattern.ASSIGN_START[1]);
								if (tmpToken.token == ""="")
								{
									//Use all characters after self symbol to set value
									tmpToken = AS3Parser.nextWord(tmpStr, tmpToken.index, AS3Pattern.ASSIGN_UPTO[0], AS3Pattern.ASSIGN_UPTO[1]);
									if (!tmpToken)
									{
										throw new Error(""Error during variable assignment in arg"" + currMember.argList[currMember.argList.length - 1].name);
									}
									//Store value
									currMember.argList[currMember.argList.length-1].value = tmpToken.token.trim();
									Main.debug('----->Function argument defaulted to: ' + tmpToken.token.trim());
								}
							}
						}
					}
					Main.debug('------>Completed paring args: ', currMember.argList);
					//Type the function if needed
					if (src.charAt(index + 1) == "":"")
					{
						tmpToken = AS3Parser.nextWord(src, index + 1, AS3Pattern.VARIABLE_TYPE[0], AS3Pattern.VARIABLE_TYPE[1]); //Parse out the function type if needed
						index = tmpToken.index;
						currMember.type = tmpToken.token;
						Main.debug('------>Typed the function to: ', currMember.type);
					}

					
					if (cls.isInterface)
					{
						//Store and delete current member and exit
						currMember.value = '{}';
						if (currMember.subType == 'get')
						{
							(currMember.isStatic) ? cls.staticGetters.push(currMember) : cls.getters.push(currMember);
						} else if (currMember.subType == 'set')
						{
							(currMember.isStatic) ? cls.staticSetters.push(currMember) : cls.setters.push(currMember);
						} else if (currMember.isStatic)
						{
							cls.staticMembers.push(currMember);
						} else
						{
							cls.members.push(currMember);
						}
						cls.registerField(currMember.name, currMember);
						//Done parsing function
						currMember = null;
						stack.pop();
					} else
					{
						//Save the function body
						AS3Parser.PREVIOUS_BLOCK = currMember.name + "":Function"";
						tmpArr = AS3Parser.extractBlock(src, index);
						index = tmpArr[1];
						currMember.value = tmpArr[0].trim();

						//Store and delete current member and exit
						if (currMember.subType == 'get')
						{
							(currMember.isStatic) ? cls.staticGetters.push(currMember) : cls.getters.push(currMember);
						} else if (currMember.subType == 'set')
						{
							(currMember.isStatic) ? cls.staticSetters.push(currMember) : cls.setters.push(currMember);
						} else if (currMember.isStatic)
						{
							cls.staticMembers.push(currMember);
						} else
						{
							cls.members.push(currMember);
						}
						cls.registerField(currMember.name, currMember);

						currMember = null;
						stack.pop();
					}
				} else if (getState() == AS3ParseState.LOCAL_VARIABLE)
				{

				} else if (getState() == AS3ParseState.LOCAL_FUNCTION)
				{

				} else if (getState() == AS3ParseState.IMPORT_PACKAGE)
				{
					//The current token is a class import
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.IMPORT[0], AS3Pattern.IMPORT[1]);
					index = currToken.index - 1;
					if (!currToken.token)
					{
						throw new Error(""Error parsing import."");
					} else
					{
						Main.debug(""Parsed import name: "" + currToken.token);
						if (currToken.token.indexOf(""*"") >= 0)
						{
							cls.importWildcards.push(currToken.token); //To be resolved later
						}
						else
						{
							cls.imports.push(currToken.token); //No need to resolve
						}
						stack.push(AS3ParseState.PACKAGE);
					}
				} else if (getState() == AS3ParseState.REQUIRE_MODULE)
				{
					//The current token is a module requirement
					currToken = AS3Parser.nextWord(src, index, AS3Pattern.REQUIRE[0], AS3Pattern.REQUIRE[1]);
					index = currToken.index - 1;
					if(!currToken.token)
						throw new Error(""Error parsing require."");
					else {
						Main.debug(""Parsed require name: "" + currToken.token);
						cls.requires.push(currToken.token.trim());
						stack.push(AS3ParseState.PACKAGE);
					}
				}
			}
		}
		public function parse(options:Object = null):AS3Class
		{
			options = options || { };
			if (typeof options.safeRequire !== 'undefined')
			{
				parserOptions.safeRequire = options.safeRequire;
			}
			if (typeof options.ignoreFlash !== 'undefined')
			{
				parserOptions.ignoreFlash = options.ignoreFlash;
			}
			
			var classDefinition:AS3Class = new AS3Class(parserOptions);
			stack.splice(0, stack.length);
			stack.push(AS3ParseState.START);
			
			parseHelper(classDefinition, src);
			
			if (!classDefinition.className)
			{
				throw new Error(""Error, no class provided for package: "" + classPath);
			}
			return classDefinition;
		}
		
		public static function checkArguments(fn:AS3Function):String
		{
			if (fn.argList.length <= 0)
			{
				return fn.value;
			}
			var start:int = fn.value.indexOf('{');
			var args:String = """";
			for (var i:int = 0; i < fn.argList.length; i++)
			{
				//We will inject arguments into the top of the method definition
				if (fn.argList[i].isRestParam)
				{
					args += ""\\n\\t\\t\\tvar "" + fn.argList[i].name + "" = Array.prototype.slice.call(arguments).splice("" + i + "");"";
				} else if (fn.argList[i].value)
				{
					args += ""\\n\\t\\t\\t"" + fn.argList[i].name + "" = AS3JS.Utils.getDefaultValue("" + fn.argList[i].name + "", "" + fn.argList[i].value + "");"";
				}
			}
			return fn.value.substr(0, start + 1) + args + fn.value.substr(start + 1);
		}
		public static function injectInstantiations(cls:AS3Class, fn:AS3Function):String
		{
			var start:int = fn.value.indexOf('{');
			var text:String = """";
			for (var i = 0; i < cls.members.length; i++)
			{
				//We will inject instantiated vars into the top of the method definition
				if (cls.members[i] instanceof AS3Variable && AS3Class.nativeTypes.indexOf(cls.members[i].type) < 0)
				{
					text += ""\\n\\t\\t\\tthis."" + cls.members[i].name + "" = "" + cls.members[i].value + "";"";
				}
			}
			return fn.value.substr(0, start + 1) + text + fn.value.substr(start + 1);
		}
		public static function injectInit(cls:AS3Class, fn:AS3Function):String
		{
			var start:int = fn.value.indexOf('{');
			var text:String = ""\\n\\t\\t\\tthis.$init();"";
			
			return fn.value.substr(0, start + 1) + text + fn.value.substr(start + 1);
		}
		public static function checkStack(stack:Array, name:String):void
		{
			if (!name)
			{
				return null;
			}
			for (var i = stack.length - 1; i >= 0; i--)
			{
				if (stack[i].name == name)
				{
					return stack[i];
				}
			}
			return null;
		}
		public static function lookAhead(str:String, index:int):Object
		{
			//Look ahead in the function for assignments
			var originalIndex:int = index;
			var startIndex:int = -1;
			var endIndex:int = -1;
			var semicolonIndex:int = -1;
			var token:String = """";
			var extracted:String = """";
			//Not a setter if there is a dot operator immediately after
			if (str.charAt(index) == '.')
			{
				return { token: null, extracted: '', startIndex: startIndex, endIndex: endIndex };
			}
			for (; index < str.length; index++)
			{
				if(str.charAt(index).match(/[+-\\/=*]/g))
				{
					//Append to the assignment instruction
					token += str.charAt(index);
					startIndex = index;
				} else if (startIndex < 0 && str.charAt(index).match(/[\\t\\s]/g)) //Skip these characters
				{
					continue;
				} else
				{
					break; //Exits when token has already been started and no more regexes pass
				}
			}
			
			//Only allow these patterns
			if (!(token == ""="" || token == ""++"" || token == ""--"" || token == ""+="" || token == ""-="" || token == ""*="" || token == ""/=""))
			{
				token = null;
			}
				
			if (token)
			{
				//Pick whatever is closer, new line or semicolon
				endIndex = str.indexOf('\\n', startIndex);
				if (endIndex < 0)
				{
					endIndex = str.length - 1;
				}
				//Windows fix
				if (str.charAt(endIndex - 1) == '\\r')
				{
					endIndex--;
				}
				//We want to place closing parens before semicolon if it exists
				semicolonIndex = str.indexOf("";"", startIndex);
				if (semicolonIndex < endIndex)
				{
					endIndex = semicolonIndex;
				}
				extracted = str.substring(startIndex + token.length, endIndex);
			}
			
			return { token: token, extracted: extracted, startIndex: startIndex, endIndex: endIndex };
		}
		public static function parseFunc(cls:AS3Class, fnText:String, stack:Array, statFlag:Boolean = false):Array
		{
			var i:int;
			var j:int;
			var index:int = 0;
			var result:String = '';
			var tmpStr:String = '';
			var tmpArgs:Vector.<AS3Argument>;
			var tmpMember:AS3Member;
			var tmpClass:AS3Class;
			var tmpField:AS3Member;
			var prevToken:AS3Token;
			var currToken:AS3Token;
			var tmpParse:String;
			var tmpStatic:Boolean = false;
			var tmpPeek:String;
			var objBuffer = ''; //Tracks the current object that is being ""pathed"" (e.g. ""object.field1"" or ""object.field1[index + 1]"", etc)
			var justCreatedVar:Boolean = false; //Keeps track if we just started a var statement (to help test if we're setting a type))
			for (index = 0; index < fnText.length; index++)
			{
				objBuffer = '';
				prevToken = currToken;
				currToken = AS3Parser.nextWord(fnText, index, AS3Pattern.VARIABLE[0], AS3Pattern.VARIABLE[1]);
				result += currToken.extra; //<-Puts all other non-identifier characters into the buffer first
				tmpMember = AS3Parser.checkStack(stack, currToken.token); //<-Check the stack for a member with this identifier already
				index = currToken.index;
				if (currToken.token)
				{
					if (currToken.token == 'function')
					{
						var t1 = AS3Parser.nextWord(fnText, index, AS3Pattern.VARIABLE[0], AS3Pattern.VARIABLE[1]);
						var t2 = fnText.indexOf('(', index);
						//If the parenthesis si less than the last index of the next parsed variable name
						result += (t2 < t1.index) ? 'function' : 'function ' + t1.token;
						tmpParse = AS3Parser.extractBlock(fnText, index, '(', ')'); //Parse out argument block
						index = tmpParse[1]; //Update index
						tmpArgs = AS3Parser.parseArguments(tmpParse[0]); //Extract arg types
						//Join the args together without types
						result += '(' + (function(args) {
							var arr = [];
							for (var i = 0; i < args.length; i++)
							{
								if (args[i] === '...rest')
								{
									break;
								}
								arr.push(args[i].name);
							}
							var str = arr.join(', ');
							return str;
						})(tmpArgs) + ')';
						tmpParse = AS3Parser.extractBlock(fnText, index, '{', '}'); //Extract function block
						index = tmpParse[1] - 1; //Update index
						tmpParse = AS3Parser.parseFunc(cls, tmpParse[0], stack.concat(tmpArgs), statFlag); //Recurse into function
						result += ' ' + tmpParse[0];
					} else
					{
						if (currToken.token == 'this')
						{
							//No need to perform any extra checks on the subsequent token
							tmpStatic = false;
							tmpClass = cls;
							objBuffer += currToken.token;
							result += currToken.token;
						} else
						{
							if (cls.classMap[currToken.token] && cls.parentDefinition !== cls.classMap[currToken.token] && !(justCreatedVar && currToken.extra.match(/:\\s*/g)))
							{
								// If this is a token that matches a class from a potential import statement, store it in the filtered classMap
								cls.classMapFiltered[currToken.token] = cls.classMap[currToken.token];
							}
							tmpStatic = (cls.className == currToken.token || cls.retrieveField(currToken.token, true) !== null);
							
							//Find field in class, then make sure we didn't already have a local member defined with this name, and skip next block if static since the definition is the class itself
							//Note: tmpMember needs to be checked, if something is in there it means we have a variable with the same name in local scope
							if (cls.retrieveField(currToken.token, tmpStatic) && cls.className != currToken.token && !tmpMember && !(prevToken && prevToken.token === ""var""))
							{
								tmpMember = cls.retrieveField(currToken.token, tmpStatic); //<-Reconciles the type of the current variable
								if (tmpMember && (tmpMember.subType == 'get' || tmpMember.subType == 'set'))
								{
									tmpPeek = AS3Parser.lookAhead(fnText, index);
									if (tmpPeek.token)
									{
										//Handle differently if we are assigning a setter
										
										//Prepend the correct term
										if (tmpStatic)
										{
											objBuffer += (cls.retrieveField(currToken.token, tmpStatic)) ? cls.className + '.' : currToken.token + '.';
											result += (cls.retrieveField(currToken.token, tmpStatic)) ? cls.className + '.' : currToken.token + '.';
										} else
										{
											objBuffer += 'this.';
											result += 'this.';
										}
										objBuffer += 'get_' + currToken.token + '()';
										result += 'set_' + currToken.token + '(';
										index = tmpPeek.endIndex;
										if (tmpPeek.token == '++')
										{
											result += objBuffer + ' + 1';
										} else if (tmpPeek.token == '--')
										{
											result += objBuffer + ' - 1';
										} else
										{
											tmpParse = AS3Parser.parseFunc(cls, tmpPeek.extracted, stack); //Recurse into the assignment to parse vars
											if (tmpPeek.token == '=')
											{
												result +=  tmpParse[0].trim();
											} else 
											{
												result += objBuffer + ' ' + tmpPeek.token.charAt(0) + ' (' + tmpParse[0] + ')';
											}
										}
										result += ')';
									} else
									{
										//Getters are easy
										if (tmpStatic)
										{
											objBuffer += (cls.retrieveField(currToken.token, true)) ? cls.className + '.get_' + currToken.token + '()' : 'this.get_' + currToken.token + '()';
											result += (cls.retrieveField(currToken.token, true)) ? cls.className + '.get_' + currToken.token + '()' : 'this.get_' + currToken.token + '()';
										} else
										{
											objBuffer += 'this.get_' + currToken.token + '()';
											result += 'this.get_' + currToken.token + '()';
										}
									}
								} else
								{
									if (tmpStatic)
									{
										objBuffer += (cls.className == currToken.token) ? currToken.token : cls.className + '.' + currToken.token;
										result += (cls.className == currToken.token) ? currToken.token : cls.className + '.' + currToken.token;
									} else
									{
										objBuffer += (cls.retrieveField(currToken.token, false) && !statFlag && !(prevToken && prevToken.token === 'new' && cls.retrieveField(currToken.token, false).type !== ""Class"")) ? 'this.' + currToken.token : currToken.token;
										result += (cls.retrieveField(currToken.token, false) && !statFlag && !(prevToken && prevToken.token === 'new' && cls.retrieveField(currToken.token, false).type !== ""Class"")) ? 'this.' + currToken.token : currToken.token;
									}
								}
							} else
							{
								//Likely a local variable, argument, or static reference
								if (tmpStatic)
								{
									objBuffer += currToken.token;
									result += currToken.token;
								} else
								{
									objBuffer += (cls.retrieveField(currToken.token, false) && !tmpMember && !(prevToken && prevToken.token === ""var"")) ? 'this.' + currToken.token : currToken.token;
									result += (cls.retrieveField(currToken.token, false) && !tmpMember && !(prevToken && prevToken.token === ""var"")) ? 'this.' + currToken.token : currToken.token;
								}
							}
							if (tmpStatic)
							{
								//Just use the class itself, we will reference fields from it. If parser injected the static prefix manually, we'll try to determome the type of var instead
								tmpClass = (cls.className == currToken.token) ? cls : (tmpMember) ? cls.classMap[tmpMember.type] || null : null; 
							} else
							{
								//Use the member's type to determine the class it's mapped to
								tmpClass = (tmpMember && tmpMember.type && tmpMember.type != '*') ? cls.classMap[tmpMember.type] : null; 
								//If no mapping was found, this may be a static reference
								if (!tmpClass && cls.classMap[currToken.token])
								{
									tmpClass = cls.classMap[currToken.token];
									tmpStatic = true;
								}
							}
							//If tmpClass is null, it's possible we were trying to retrieve a Vector type. Let's fix this:
							if (!tmpClass && tmpMember && tmpMember.type && tmpMember.type.replace(/Vector\\.<(.*?)>/g, ""$1"") != tmpMember.type)
							{
								//Extract Vector type if necessary by testing regex
								tmpClass = cls.classMap[tmpMember.type.replace(/Vector\\.<(.*?)>/g, ""$1"")] || null;
							}
						}
						//Note: At this point, tmpMember is no longer used, it was only needed to remember the type of the first token. objBuffer will be building out the token
						
						//If this had a variable declaration before it, we will add it to the local var stack and move on to the next token
						if (prevToken && prevToken.token === ""var"")
						{
							justCreatedVar = true;
							if (cls.retrieveField(currToken.token, tmpStatic))
							{
								//Appends current character index to the result, add dummy var to stack, and move on
								result += fnText.charAt(index);
								var localVar:AS3Member = new AS3Member();
								localVar.name = currToken.token;
								stack.push(localVar); //<-Ensures we don't add ""this."" or anything in front of this variable anymore
								continue;
							}
						} else
						{
							justCreatedVar = false;
						}
						
						//We have parsed the current token, and the index sits at the next level down in the object
						for (; index < fnText.length; index++)
						{
							//Loop until we stop parsing a variable declaration
							if (fnText.charAt(index) == '.')
							{
								var parsingVector =  (prevToken && prevToken.token === 'new' && currToken.token === 'Vector');
								prevToken = currToken;
								if (parsingVector)
								{
									//We need to allow asterix
									currToken = AS3Parser.nextWord(fnText, index, AS3Pattern.VARIABLE_TYPE[0], AS3Pattern.VARIABLE_TYPE[1]);
								} else
								{
									currToken = AS3Parser.nextWord(fnText, index, AS3Pattern.VARIABLE[0], AS3Pattern.VARIABLE[1]);
								}
								result += currToken.extra; //<-Puts all other non-identifier characters into the buffer first
								index = currToken.index;
								if (tmpClass)
								{
									//This means we are coming from a typed variable
									tmpField = tmpClass.retrieveField(currToken.token, tmpStatic);
									if (tmpField)
									{
										//console.log(""parsing: "" + tmpField.name + "":"" + tmpField.type)
										//We found a field that matched this value within the class
										if (tmpField instanceof AS3Function)
										{
											if (tmpField.subType == 'get' || tmpField.subType == 'set')
											{
												tmpPeek = AS3Parser.lookAhead(fnText, index);
												if (tmpPeek.token)
												{
													//Handle differently if we are assigning a setter
													objBuffer += '.get_' + currToken.token + '()';
													result += 'set_' + currToken.token + '(';
													index = tmpPeek.endIndex;
													if (tmpPeek.token == '++')
													{
														result += objBuffer + ' + 1';
													} else if (tmpPeek.token == '--')
													{
														result += objBuffer + ' - 1';
													} else
													{
														tmpParse = AS3Parser.parseFunc(cls, tmpPeek.extracted, stack); //Recurse into the assignment to parse vars
														if (tmpPeek.token == '=')
														{
															result += tmpParse[0].trim();
														} else
														{
															result += objBuffer + ' ' + tmpPeek.token.charAt(0) + ' (' + tmpParse[0] + ')';
														}
													}
													result += ')';
												} else
												{
													objBuffer += '.get_' + currToken.token + '()';
													result += 'get_' + currToken.token + ""()"";
												}
												//console.log(""set get flag: "" + currToken.token);
											} else
											{
												objBuffer += '.' + currToken.token;
												result += currToken.token;
											}
										} else
										{
											objBuffer += '.' + currToken.token;
											result += currToken.token;
										}
									} else
									{
										objBuffer += '.' + currToken.token;
										result += currToken.token;
										//console.log(""appened typed: "" + currToken.token);
									}
									//Update the type if this is not a static prop
									if (tmpClass && tmpField && tmpField.type && tmpField.type != '*')
									{
										//Extract Vector type if necessary by testing regex
										tmpClass = (tmpField.type.replace(/Vector\\.<(.*?)>/g, ""$1"") != tmpField.type) ? tmpClass.classMap[tmpField.type.replace(/Vector\\.<(.*?)>/g, ""$1"")] || null : tmpClass.classMap[tmpField.type] || null;
									} else
									{
										tmpClass = null;
									}
								} else
								{
									//console.log(""appened untyped: "" + currToken.token);
									objBuffer += '.' + currToken.token;
									result += currToken.token;
								}
							} else if (fnText.charAt(index) == '[')
							{
								//We now have to recursively parse the inside of this open bracket
								tmpParse = AS3Parser.extractBlock(fnText, index, '[', ']');
								index = tmpParse[1];
								tmpParse = AS3Parser.parseFunc(cls, tmpParse[0], stack); //Recurse into the portion that was extracted
								//console.log(""recursed into: "" + tmpParse[0]);
								objBuffer += tmpParse[0]; //Append this text to the object buffer string so we can remember the variable we have accessed
								result += tmpParse[0];
							}
							tmpStatic = false; //Static can no longer be possible after the second field
							if (!fnText.charAt(index).match(/[.\\[]/g)) 
							{
								objBuffer = ''; //Clear out the current object buffer
								index--;
								break;
							}
							index--;
						}
					}
				} else
				{
					index = currToken.index - 1;
				}
			}
			return [result, index];
		}
		public static function cleanup(text:String):String
		{
			var i:int;
			var type:String;
			var params:Array;
			var val:String;
			var matches:Array = text.match(AS3Pattern.VECTOR[0]);
			//For each Vector.<>() found in the text
			for (i in matches)
			{
				//Strip the type and provided params
				type = matches[i].replace(AS3Pattern.VECTOR[0], '$1').trim();
				params = matches[i].replace(AS3Pattern.VECTOR[0], '$2').split(',');
				//Set the default based on var type
				if (type == 'int' || type == 'uint' || type == 'Number')
				{
					val = ""0"";
				} else if (type == 'Boolean')
				{
					val = ""false"";
				} else
				{
					val = ""null"";
				}
				//Replace accordingly
				if (params.length > 0 && params[0].trim() != '')
				{
					text = text.replace(AS3Pattern.VECTOR[1], ""AS3JS.Utils.createArray("" + params[0] + "", "" + val + "")"");
				} else
				{
					text = text.replace(AS3Pattern.VECTOR[1], ""[]"");
				}
			}
			matches = text.match(AS3Pattern.ARRAY[0]);
			//For each Array() found in the text
			for (i in matches)
			{
				//Strip the provided params
				params = matches[i].replace(AS3Pattern.ARRAY[0], '$1').trim();
				//Replace accordingly
				if (params.length > 0 && params[0].trim() != '')
				{
					text = text.replace(AS3Pattern.ARRAY[1], ""AS3JS.Utils.createArray("" + params[0] + "", null)"");
				} else
				{
					text = text.replace(AS3Pattern.ARRAY[1], ""[]"");
				}
			}
			
			matches = text.match(AS3Pattern.DICTIONARY[0]);
			//For each instantiated Dictionary found in the text
			for (i in matches)
			{
				// Replace with empty object
				text = text.replace(AS3Pattern.DICTIONARY[0], ""{}"");
			}
			
			//Now cleanup variable types
			text = text.replace(/([^0-9a-zA-Z_$.])(?:var|const)(\\s*[a-zA-Z_$*][0-9a-zA-Z_$.<>]*)\\s*:\\s*([a-zA-Z_$*][0-9a-zA-Z_$.<>]*)/g, ""$1var$2"");
			
			return text;
		}
	}
}",12540,False,2386.1784480208403,median
"/**
 * VERSION: 1.66
 * DATE: 2011-01-25
 * AS3 (AS2 version is also available)
 * UPDATES AND DOCS AT: http://www.greensock.com/timelinemax/
 **/
package com.greensock {
	import com.greensock.core.*;
	import com.greensock.events.TweenEvent;
	
	import flash.events.*;
/**
 * 	TimelineMax extends TimelineLite, offering exactly the same functionality plus useful 
 *  (but non-essential) features like AS3 event dispatching, repeat, repeatDelay, yoyo, 
 *  currentLabel, addCallback(), removeCallback(), tweenTo(), tweenFromTo(), getLabelAfter(), getLabelBefore(),
 * 	and getActive() (and probably more in the future). It is the ultimate sequencing tool. 
 *  Think of a TimelineMax instance like a virtual MovieClip timeline or a container where 
 *  you place tweens (or other timelines) over the course of time. You can:
 * 	
 * <ul>
 * 		<li> build sequences easily by adding tweens with the append(), prepend(), insert(), appendMultiple(), 
 * 			prependMultiple(), and insertMultiple() methods. Tweens can overlap as much as you want and you have 
 * 			complete control over where they get placed on the timeline.</li>
 * 
 * 		<li> add labels, play(), stop(), gotoAndPlay(), gotoAndStop(), restart(), tweenTo() and even reverse()! </li>
 * 		
 * 		<li> nest timelines within timelines as deeply as you want.</li>
 * 		
 * 		<li> set the progress of the timeline using its <code>currentProgress</code> property. For example, to skip to
 * 		  the halfway point, set <code>myTimeline.currentProgress = 0.5</code>.</li>
 * 		  
 * 		<li> tween the <code>currentTime</code>, <code>totalTime</code>, <code>currentProgress</code>, or <code>totalProgress</code> 
 * 		 property to fastforward/rewind the timeline. You could 
 * 		  even attach a slider to one of these properties to give the user the ability to drag 
 * 		  forwards/backwards through the whole timeline.</li>
 * 		  
 * 		<li> add onStart, onUpdate, onComplete, onReverseComplete, and/or onRepeat callbacks using the 
 * 		  constructor's <code>vars</code> object.</li>
 * 		
 * 		<li> speed up or slow down the entire timeline with its <code>timeScale</code> property. You can even tween
 * 		  this property to gradually speed up or slow down the timeline.</li>
 * 		  
 * 		<li> use the insertMultiple(), appendMultiple(), or prependMultiple() methods to create 
 * 			complex sequences including various alignment modes and staggering capabilities.  
 * 			Works great in conjunction with TweenMax.allTo() too. </li>
 * 		  
 * 		<li> base the timing on frames instead of seconds if you prefer. Please note, however, that
 * 		  the timeline's timing mode dictates its childrens' timing mode as well. </li>
 * 		
 * 		<li> kill the tweens of a particular object inside the timeline with killTweensOf() or get the tweens of an object
 * 		  with getTweensOf() or get all the tweens/timelines in the timeline with getChildren()</li>
 * 		  
 * 		<li> set the timeline to repeat any number of times or indefinitely. You can even set a delay
 * 		  between each repeat cycle and/or cause the repeat cycles to yoyo, appearing to reverse
 * 		  every other cycle. </li>
 * 		
 * 		<li> listen for START, UPDATE, REPEAT, REVERSE_COMPLETE, and COMPLETE events.</li>
 * 		
 * 		<li> get the active tweens in the timeline with getActive().</li>
 * 
 * 		<li> add callbacks (function calls) anywhere in the timeline that call a function of your choosing when 
 * 			the ""virtual playhead"" passes a particular spot.</li>
 * 		
 * 		<li> Get the <code>currentLabel</code> or find labels at various positions in the timeline
 * 			using getLabelAfter() and getLabelBefore()</li>
 * 	</ul>
 * 	
 * <b>EXAMPLE:</b><br /><br /><code>
 * 		
 * 		import com.greensock.~~;<br /><br />
 * 		
 * 		//create the timeline and add an onComplete call to myFunction when the timeline completes<br />
 * 		var myTimeline:TimelineMax = new TimelineMax({onComplete:myFunction});<br /><br />
 * 		
 * 		//add a tween<br />
 * 		myTimeline.append(new TweenLite(mc, 1, {x:200, y:100}));<br /><br />
 * 		
 * 		//add another tween at the end of the timeline (makes sequencing easy)<br />
 * 		myTimeline.append(new TweenLite(mc, 0.5, {alpha:0}));<br /><br />
 * 		
 * 		//repeat the entire timeline twice<br />
 * 		myTimeline.repeat = 2;<br /><br />
 * 		
 * 		//delay the repeat by 0.5 seconds each time.<br />
 * 		myTimeline.repeatDelay = 0.5;<br /><br />
 * 		
 * 		//pause the timeline (stop() works too)<br />
 * 		myTimeline.pause();<br /><br />
 * 		
 * 		//reverse it anytime...<br />
 * 		myTimeline.reverse();<br /><br />
 * 		
 * 		//Add a ""spin"" label 3-seconds into the timeline.<br />
 * 		myTimeline.addLabel(""spin"", 3);<br /><br />
 * 		
 * 		//insert a rotation tween at the ""spin"" label (you could also define the insert point as the time instead of a label)<br />
 * 		myTimeline.insert(new TweenLite(mc, 2, {rotation:""360""}), ""spin""); <br /><br />
 * 		
 * 		//go to the ""spin"" label and play the timeline from there...<br />
 * 		myTimeline.gotoAndPlay(""spin"");<br /><br />
 * 
 * 		//call myCallbackwhen the ""virtual playhead"" travels past the 1.5-second point.
 * 		myTimeline.addCallback(myCallback, 1.5);
 * 		
 * 		//add a tween to the beginning of the timeline, pushing all the other existing tweens back in time<br />
 * 		myTimeline.prepend(new TweenMax(mc, 1, {tint:0xFF0000}));<br /><br />
 * 		
 * 		//nest another TimelineMax inside your timeline...<br />
 * 		var nestedTimeline:TimelineMax = new TimelineMax();<br />
 * 		nestedTimeline.append(new TweenLite(mc2, 1, {x:200}));<br />
 * 		myTimeline.append(nestedTimeline);<br /><br /></code>
 * 		
 * 		
 * 	<code>insertMultiple()</code> and <code>appendMultiple()</code> provide some very powerful sequencing tools as well, 
 *  allowing you to add an Array of tweens/timelines and optionally align them with <code>SEQUENCE</code> or <code>START</code> 
 *  modes, and even stagger them if you want. For example, to insert 3 tweens into the timeline, aligning their start times but 
 *  staggering them by 0.2 seconds, <br /><br /><code>
 * 	
 * 		myTimeline.insertMultiple([new TweenLite(mc, 1, {y:""100""}),
 * 								   new TweenLite(mc2, 1, {x:120}),
 * 								   new TweenLite(mc3, 1, {alpha:0.5})], 
 * 								   0, 
 * 								   TweenAlign.START, 
 * 								   0.2);</code><br /><br />
 * 								   
 * 	You can use the constructor's <code>vars</code> object to do all the setup too, like:<br /><br /><code>
 * 	
 * 		var myTimeline:TimelineMax = new TimelineMax({tweens:[new TweenLite(mc1, 1, {y:""100""}), TweenMax.to(mc2, 1, {tint:0xFF0000})], align:TweenAlign.SEQUENCE, onComplete:myFunction, repeat:2, repeatDelay:1});</code><br /><br />
 * 	
 * 	If that confuses you, don't worry. Just use the <code>append()</code>, <code>insert()</code>, and <code>prepend()</code> methods to build your
 * 	sequence. But power users will likely appreciate the quick, compact way they can set up sequences now. <br /><br />
 *  
 *
 * <b>NOTES:</b>
 * <ul>
 * 	<li> TimelineMax automatically inits the OverwriteManager class to prevent unexpected overwriting behavior in sequences.
 * 	  The default mode is <code>AUTO</code>, but you can set it to whatever you want with <code>OverwriteManager.init()</code>
 * 	 (see <a href=""http://www.greensock.com/overwritemanager/"">http://www.greensock.com/overwritemanager/</a>)</li>
 * 	<li> TimelineMax adds about 4.9k to your SWF (not including OverwriteManager).</li>
 * </ul>
 * 
 * <b>Copyright 2011, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href=""http://www.greensock.com/terms_of_use.html"">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
 * 
 * @author Jack Doyle, jack@greensock.com
 **/
	public class TimelineMax extends TimelineLite implements IEventDispatcher {
		/** @private **/
		public static const version:Number = 1.66;
		
		/** @private **/
		protected var _repeat:int;
		/** @private **/
		protected var _repeatDelay:Number;
		/** @private **/
		protected var _cyclesComplete:int;
		/** @private **/
		protected var _dispatcher:EventDispatcher;
		/** @private **/
		protected var _hasUpdateListener:Boolean;
		
		/** 
		 * Works in conjunction with the repeat property, determining the behavior of each cycle; when <code>yoyo</code> is true, 
		 * the timeline will go back and forth, appearing to reverse every other cycle (this has no affect on the <code>reversed</code> property though). 
		 * So if repeat is 2 and <code>yoyo</code> is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. 
		 * But if repeat is 2 and <code>yoyo</code> is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end.  
		 **/
		 public var yoyo:Boolean;
		
		/**
		 * Constructor. <br /><br />
		 * 
		 * <b>SPECIAL PROPERTIES</b><br />
		 * The following special properties may be passed in via the constructor's vars parameter, like
		 * <code>new TimelineMax({paused:true, onComplete:myFunction, repeat:2, yoyo:true})</code> 
		 * 
		 * <ul>
		 * 	<li><b> delay : Number</b>				Amount of delay in seconds (or frames for frames-based timelines) before the timeline should begin.</li>
		 * 								
		 * 	<li><b> useFrames : Boolean</b>			If <code>useFrames</code> is set to true, the timeline's timing mode will be based on frames. 
		 * 											Otherwise, it will be based on seconds/time. NOTE: a TimelineLite's timing mode is 
		 * 											always determined by its parent timeline. </li>
		 * 
		 *  <li><b> paused : Boolean</b> 			Sets the initial paused state of the timeline (by default, timelines automatically begin playing immediately)</li>
		 * 
		 * 	<li><b> reversed : Boolean</b>			If true, the timeline will be reversed initially. This does NOT force it to the very end and start 
		 * 											playing backwards. It simply affects the orientation of the timeline, so if <code>reversed</code> is set to 
		 * 											true initially, it will appear not to play because it is already at the beginning. To cause it to
		 * 											play backwards from the end, set reversed to true and then set the <code>currentProgress</code> property to 1 immediately
		 * 											after creating the timeline.</li>
		 * 									
		 * 	<li><b> tweens : Array</b>				To immediately insert several tweens into the timeline, use the <code>tweens</code> special property
		 * 											to pass in an Array of TweenLite/TweenMax/TimelineLite/TimelineMax instances. You can use this in conjunction
		 * 											with the <code>align</code> and <code>stagger</code> special properties to set up complex sequences with minimal code.
		 * 											These values simply get passed to the <code>insertMultiple()</code> method.</li>
		 * 	
		 * 	<li><b> align : String</b>				Only used in conjunction with the <code>tweens</code> special property when multiple tweens are
		 * 											to be inserted immediately through the constructor. The value simply gets passed to the 
		 * 											<code>insertMultiple()</code> method. The default is <code>TweenAlign.NORMAL</code>. Options are:
		 * 											<ul>
		 * 												<li><b> TweenAlign.SEQUENCE:</b> aligns the tweens one-after-the-other in a sequence</li>
		 * 												<li><b> TweenAlign.START:</b> aligns the start times of all of the tweens (ignores delays)</li>
		 * 												<li><b> TweenAlign.NORMAL:</b> aligns the start times of all the tweens (honors delays)</li>
		 * 											</ul>The <code>align</code> special property does <b>not</b> force all child tweens/timelines to maintain
		 * 											relative positioning, so for example, if you use TweenAlign.SEQUENCE and then later change the duration
		 * 											of one of the nested tweens, it does <b>not</b> force all subsequent timelines to change their position
		 * 											on the timeline. The <code>align</code> special property only affects the alignment of the tweens that are
		 * 											initially placed into the timeline through the <code>tweens</code> special property of the <code>vars</code> object.</li>
		 * 										
		 * 	<li><b> stagger : Number</b>			Only used in conjunction with the <code>tweens</code> special property when multiple tweens are
		 * 											to be inserted immediately. It staggers the tweens by a set amount of time (in seconds) (or
		 * 											in frames if <code>useFrames</code> is true). For example, if the stagger value is 0.5 and the <code>align</code> 
		 * 											property is set to <code>TweenAlign.START</code>, the second tween will start 0.5 seconds after the first one 
		 * 											starts, then 0.5 seconds later the third one will start, etc. If the align property is 
		 * 											<code>TweenAlign.SEQUENCE</code>, there would be 0.5 seconds added between each tween. This value simply gets 
		 * 											passed to the <code>insertMultiple()</code> method. Default is 0.</li>
		 * 	
		 * 	<li><b> onStart : Function</b>			A function that should be called when the timeline begins (the <code>currentProgress</code> won't necessarily
		 * 											be zero when onStart is called. For example, if the timeline is created and then its <code>currentProgress</code>
		 * 											property is immediately set to 0.5 or if its <code>currentTime</code> property is set to something other than zero,
		 * 											onStart will still get fired because it is the first time the timeline is getting rendered.)</li>
		 * 	
		 * 	<li><b> onStartParams : Array</b>		An Array of parameters to pass the onStart function.</li>
		 * 	
		 * 	<li><b> onUpdate : Function</b>			A function that should be called every time the timeline's time/position is updated 
		 * 											(on every frame while the timeline is active)</li>
		 * 	
		 * 	<li><b> onUpdateParams : Array</b>		An Array of parameters to pass the onUpdate function</li>
		 * 	
		 * 	<li><b> onComplete : Function</b>		A function that should be called when the timeline has finished </li>
		 * 	
		 * 	<li><b> onCompleteParams : Array</b>	An Array of parameters to pass the onComplete function</li>
		 * 	
		 * 	<li><b> onReverseComplete : Function</b> A function that should be called when the timeline has reached its starting point again after having been reversed </li>
		 * 	
		 * 	<li><b> onReverseCompleteParams : Array</b> An Array of parameters to pass the onReverseComplete functions</li>
		 *  
		 * 	<li><b> onRepeat : Function</b>			A function that should be called every time the timeline repeats </li>
		 * 	
		 * 	<li><b> onRepeatParams : Array</b>		An Array of parameters to pass the onRepeat function</li>
		 * 	
		 * 	<li><b> autoRemoveChildren : Boolean</b> If autoRemoveChildren is set to true, as soon as child tweens/timelines complete,
		 * 											they will automatically get killed/removed. This is normally undesireable because
		 * 											it prevents going backwards in time (like if you want to reverse() or set the 
		 * 											<code>currentProgress</code> value to a lower value, etc.). It can, however, improve speed and memory
		 * 											management. TweenLite's root timelines use <code>autoRemoveChildren:true</code>.</li>
		 * 
		 * 	<li><b> repeat : int</b>				Number of times that the timeline should repeat. To repeat indefinitely, use -1.</li>
		 * 	
		 * 	<li><b> repeatDelay : Number</b>		Amount of time in seconds (or frames for frames-based timelines) between repeats.</li>
		 * 	
		 * 	<li><b> yoyo : Boolean</b> 				Works in conjunction with the repeat property, determining the behavior of each 
		 * 											cycle. When <code>yoyo</code> is true, the timeline will go back and forth, appearing to reverse 
		 * 											every other cycle (this has no affect on the <code>reversed</code> property though). So if repeat is
		 * 											2 and yoyo is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. But 
		 * 											if repeat is 2 and yoyo is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end. </li>
		 * 									
		 * 	<li><b> onStartListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent when it begins.
		 * 	  										This is the same as doing <code>myTimeline.addEventListener(TweenEvent.START, myFunction);</code></li>
		 * 	
		 * 	<li><b> onUpdateListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent every time it 
		 * 											updates values.	This is the same as doing <code>myTimeline.addEventListener(TweenEvent.UPDATE, myFunction);</code></li>
		 * 	  
		 * 	<li><b> onCompleteListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent when it completes.
		 * 	  											This is the same as doing <code>myTimeline.addEventListener(TweenEvent.COMPLETE, myFunction);</code></li>
		 * 	</ul>
		 * 
		 * @param vars optionally pass in special properties like useFrames, onComplete, onCompleteParams, onUpdate, onUpdateParams, onStart, onStartParams, tweens, align, stagger, delay, autoRemoveChildren, onCompleteListener, onStartListener, onUpdateListener, repeat, repeatDelay, and/or yoyo.
		 */
		public function TimelineMax(vars:Object=null) {
			super(vars);
			_repeat = (this.vars.repeat) ? Number(this.vars.repeat) : 0;
			_repeatDelay = (this.vars.repeatDelay) ? Number(this.vars.repeatDelay) : 0;
			_cyclesComplete = 0;
			this.yoyo = Boolean(this.vars.yoyo == true);
			this.cacheIsDirty = true;
			if (this.vars.onCompleteListener != null || this.vars.onUpdateListener != null || this.vars.onStartListener != null || this.vars.onRepeatListener != null || this.vars.onReverseCompleteListener != null) {
				initDispatcher();
			}
		}
		
		/**
		 * If you want a function to be called at a particular time or label, use addCallback. When you add
		 * a callback, it is technically considered a zero-duration tween, so if you getChildren() there will be
		 * a tween returned for each callback. You can discern a callback from other tweens by the fact that
		 * their target is a function and the duration is zero. 
		 * 
		 * @param function the function to be called
		 * @param timeOrLabel the time in seconds (or frames for frames-based timelines) or label at which the callback should be inserted. For example, myTimeline.addCallback(myFunction, 3) would call myFunction() 3-seconds into the timeline, and myTimeline.addCallback(myFunction, ""myLabel"") would call it at the ""myLabel"" label.
		 * @param params an Array of parameters to pass the callback
		 * @return TweenLite instance
		 */
		public function addCallback(callback:Function, timeOrLabel:*, params:Array=null):TweenLite {
			var cb:TweenLite = new TweenLite(callback, 0, {onComplete:callback, onCompleteParams:params, overwrite:0, immediateRender:false});
			insert(cb, timeOrLabel);
			return cb;
		}
		
		/**
		 * Removes a callback from a particular time or label. If timeOrLabel is null, all callbacks of that
		 * particular function are removed from the timeline.
		 * 
		 * @param function callback function to be removed
		 * @param timeOrLabel the time in seconds (or frames for frames-based timelines) or label from which the callback should be removed. For example, <code>myTimeline.removeCallback(myFunction, 3)</code> would remove the callback from 3-seconds into the timeline, and <code>myTimeline.removeCallback(myFunction, ""myLabel"")</code> would remove it from the ""myLabel"" label, and <code>myTimeline.removeCallback(myFunction, null)</code> would remove ALL callbacks of that function regardless of where they are on the timeline.
		 * @return true if any callbacks were successfully found and removed. false otherwise.
		 */
		public function removeCallback(callback:Function, timeOrLabel:*=null):Boolean {
			if (timeOrLabel == null) {
				return killTweensOf(callback, false);
			} else {
				if (typeof(timeOrLabel) == ""string"") {
					if (!(timeOrLabel in _labels)) {
						return false;
					}
					timeOrLabel = _labels[timeOrLabel];
				}
				var a:Array = getTweensOf(callback, false), success:Boolean;
				var i:int = a.length;
				while (--i > -1) {
					if (a[i].cachedStartTime == timeOrLabel) {
						remove(a[i] as TweenCore);
						success = true;
					}
				}
				return success;
			}
		}
		
		/**
		 * Creates a linear tween that essentially scrubs the playhead to a particular time or label and then stops. For 
		 * example, to make the TimelineMax play to the ""myLabel2"" label, simply do: <br /><br /><code>
		 * 
		 * myTimeline.tweenTo(""myLabel2""); <br /><br /></code>
		 * 
		 * If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, 
		 * just pass in a vars object with the appropriate properties. For example, to tween to the 5-second point on the 
		 * timeline and then call a function named <code>myFunction</code> and pass in a parameter that's references this 
		 * TimelineMax and use a Strong.easeOut ease, you'd do: <br /><br /><code>
		 * 
		 * myTimeline.tweenTo(5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});<br /><br /></code>
		 * 
		 * Remember, this method simply creates a TweenLite instance that tweens the <code>currentTime</code> property of your timeline. 
		 * So you can store a reference to that tween if you want, and you can kill() it anytime. Also note that <code>tweenTo()</code>
		 * does <b>NOT</b> affect the timeline's <code>reversed</code> property. So if your timeline is oriented normally
		 * (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards
		 * but the <code>reversed</code> property will <b>not</b> change to <code>true</code>. Also note that <code>tweenTo()</code>
		 * pauses the timeline immediately before tweening its <code>currentTime</code> property, and it stays paused after the tween completes.
		 * If you need to resume playback, you could always use an onComplete to call the <code>resume()</code> method.<br /><br />
		 * 
		 * If you plan to sequence multiple playhead tweens one-after-the-other, it is typically better to use 
		 * <code>tweenFromTo()</code> so that you can define the starting point and ending point, allowing the 
		 * duration to be accurately determined immediately. 
		 * 
		 * @see #tweenFromTo()
		 * @param timeOrLabel The destination time in seconds (or frame if the timeline is frames-based) or label to which the timeline should play. For example, myTimeline.tweenTo(5) would play from wherever the timeline is currently to the 5-second point whereas myTimeline.tweenTo(""myLabel"") would play to wherever ""myLabel"" is on the timeline.
		 * @param vars An optional vars object that will be passed to the TweenLite instance. This allows you to define an onComplete, ease, delay, or any other TweenLite special property. onInit is the only special property that is not available (tweenTo() sets it internally)
		 * @return TweenLite instance that handles tweening the timeline to the desired time/label.
		 */
		public function tweenTo(timeOrLabel:*, vars:Object=null):TweenLite {
			var varsCopy:Object = {ease:easeNone, overwrite:2, useFrames:this.useFrames, immediateRender:false};
			for (var p:String in vars) {
				varsCopy[p] = vars[p];
			}
			varsCopy.onInit = onInitTweenTo;
			varsCopy.onInitParams = [null, this, NaN];
			varsCopy.currentTime = parseTimeOrLabel(timeOrLabel);
			var tl:TweenLite = new TweenLite(this, (Math.abs(Number(varsCopy.currentTime) - this.cachedTime) / this.cachedTimeScale) || 0.001, varsCopy);
			tl.vars.onInitParams[0] = tl;
			return tl;
		}
		
		/**
		 * Creates a linear tween that essentially scrubs the playhead from a particular time or label to another 
		 * time or label and then stops. If you plan to sequence multiple playhead tweens one-after-the-other, 
		 * <code>tweenFromTo()</code> is better to use than <code>tweenTo()</code> because it allows the duration 
		 * to be determined immediately, ensuring that subsequent tweens that are appended to a sequence are 
		 * positioned appropriately. For example, to make the TimelineMax play from the label ""myLabel1"" to the ""myLabel2"" 
		 * label, and then from ""myLabel2"" back to the beginning (a time of 0), simply do: <br /><br /><code>
		 * 
		 * var playheadTweens:TimelineMax = new TimelineMax(); <br />
		 * playheadTweens.append( myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"") );<br />
		 * playheadTweens.append( myTimeline.tweenFromTo(""myLabel2"", 0); <br /><br /></code>
		 * 
		 * If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, 
		 * just pass in a vars object with the appropriate properties. For example, to tween from the start (0) to the 
		 * 5-second point on the timeline and then call a function named <code>myFunction</code> and pass in a parameter 
		 * that's references this TimelineMax and use a Strong.easeOut ease, you'd do: <br /><br /><code>
		 * 
		 * myTimeline.tweenFromTo(0, 5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});<br /><br /></code>
		 * 
		 * Remember, this method simply creates a TweenLite instance that tweens the <code>currentTime</code> property of your timeline. 
		 * So you can store a reference to that tween if you want, and you can <code>kill()</code> it anytime. Also note that <code>tweenFromTo()</code>
		 * does <b>NOT</b> affect the timeline's <code>reversed</code> property. So if your timeline is oriented normally
		 * (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards
		 * but the <code>reversed</code> property will <b>not</b> change to <code>true</code>. Also note that <code>tweenFromTo()</code>
		 * pauses the timeline immediately before tweening its <code>currentTime</code> property, and it stays paused after the tween completes.
		 * If you need to resume playback, you could always use an onComplete to call the <code>resume()</code> method.
		 * 
		 * @see #tweenTo()
		 * @param fromTimeOrLabel The beginning time in seconds (or frame if the timeline is frames-based) or label from which the timeline should play. For example, <code>myTimeline.tweenTo(0, 5)</code> would play from 0 (the beginning) to the 5-second point whereas <code>myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"")</code> would play from ""myLabel1"" to ""myLabel2"".
		 * @param toTimeOrLabel The destination time in seconds (or frame if the timeline is frames-based) or label to which the timeline should play. For example, <code>myTimeline.tweenTo(0, 5)</code> would play from 0 (the beginning) to the 5-second point whereas <code>myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"")</code> would play from ""myLabel1"" to ""myLabel2"".
		 * @param vars An optional vars object that will be passed to the TweenLite instance. This allows you to define an onComplete, ease, delay, or any other TweenLite special property. onInit is the only special property that is not available (<code>tweenFromTo()</code> sets it internally)
		 * @return TweenLite instance that handles tweening the timeline between the desired times/labels.
		 */
		public function tweenFromTo(fromTimeOrLabel:*, toTimeOrLabel:*, vars:Object=null):TweenLite {
			var tl:TweenLite = tweenTo(toTimeOrLabel, vars);
			tl.vars.onInitParams[2] = parseTimeOrLabel(fromTimeOrLabel);
			tl.duration = Math.abs(Number(tl.vars.currentTime) - tl.vars.onInitParams[2]) / this.cachedTimeScale;
			return tl;
		}
		
		/** @private **/
		private static function onInitTweenTo(tween:TweenLite, timeline:TimelineMax, fromTime:Number):void {
			timeline.paused = true;
			if (!isNaN(fromTime)) {
				timeline.currentTime = fromTime;
			}
			if (tween.vars.currentTime != timeline.currentTime) { //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all.
				tween.duration = Math.abs(Number(tween.vars.currentTime) - timeline.currentTime) / timeline.cachedTimeScale;
			}
		}
		
		/** @private **/
		private static function easeNone(t:Number, b:Number, c:Number, d:Number):Number {
			return t / d;
		}
		
		
		/** @private **/
		override public function renderTime(time:Number, suppressEvents:Boolean=false, force:Boolean=false):void {
			if (this.gc) {
				this.setEnabled(true, false);
			} else if (!this.active && !this.cachedPaused) {
				this.active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done.
			}
			var totalDur:Number = (this.cacheIsDirty) ? this.totalDuration : this.cachedTotalDuration, prevTime:Number = this.cachedTime, prevTotalTime:Number = this.cachedTotalTime, prevStart:Number = this.cachedStartTime, prevTimeScale:Number = this.cachedTimeScale, tween:TweenCore, isComplete:Boolean, rendered:Boolean, repeated:Boolean, next:TweenCore, dur:Number, prevPaused:Boolean = this.cachedPaused;
			if (time >= totalDur) {
				if (_rawPrevTime <= totalDur && _rawPrevTime != time) {
					this.cachedTotalTime = totalDur;
					if (!this.cachedReversed && this.yoyo && _repeat % 2 != 0) {
						this.cachedTime = 0;
						forceChildrenToBeginning(0, suppressEvents);
					} else {
						this.cachedTime = this.cachedDuration;
						forceChildrenToEnd(this.cachedDuration, suppressEvents);
					}
					isComplete = !this.hasPausedChild();
					rendered = true;
					if (this.cachedDuration == 0 && isComplete && (time == 0 || _rawPrevTime < 0)) { //In order to accommodate zero-duration timelines, we must discern the momentum/direction of time in order to render values properly when the ""playhead"" goes past 0 in the forward direction or lands directly on it, and also when it moves past it in the backward direction (from a postitive time to a negative time).
						force = true;
					}
				}
				
			} else if (time <= 0) {
				if (time < 0) {
					this.active = false; 
					if (this.cachedDuration == 0 && _rawPrevTime >= 0) { //In order to accommodate zero-duration timelines, we must discern the momentum/direction of time in order to render values properly when the ""playhead"" goes past 0 in the forward direction or lands directly on it, and also when it moves past it in the backward direction (from a postitive time to a negative time).
						force = true;
						isComplete = true;
					}
				} else if (time == 0 && !this.initted) {
					force = true;
				}
				if (_rawPrevTime >= 0 && _rawPrevTime != time) {
					this.cachedTotalTime = 0;
					this.cachedTime = 0;
					forceChildrenToBeginning(0, suppressEvents);
					rendered = true;
					if (this.cachedReversed) {
						isComplete = true;
					}
				}
			} else {
				this.cachedTotalTime = this.cachedTime = time;
			}
			_rawPrevTime = time;
			
			if (_repeat != 0) {
				var cycleDuration:Number = this.cachedDuration + _repeatDelay;
				var prevCycles:int = _cyclesComplete;
				_cyclesComplete = (this.cachedTotalTime / cycleDuration) >> 0; //rounds result, like int()
				if (_cyclesComplete == this.cachedTotalTime / cycleDuration) {
					_cyclesComplete--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning)
				}
				if (prevCycles != _cyclesComplete) {
					repeated = true;
				}
				
				if (isComplete) {
					if (this.yoyo && _repeat % 2) {
						this.cachedTime = 0;
					}
				} else if (time > 0) {
					this.cachedTime = ((this.cachedTotalTime / cycleDuration) - _cyclesComplete) * cycleDuration; //originally this.cachedTotalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but Flash reports it as 0.79999999!)
					
					if (this.yoyo && _cyclesComplete % 2) {
						this.cachedTime = this.cachedDuration - this.cachedTime;
					} else if (this.cachedTime >= this.cachedDuration) {
						this.cachedTime = this.cachedDuration;
					}
					if (this.cachedTime < 0) {
						this.cachedTime = 0;
					}
				} else {
					_cyclesComplete = 0;
				}
				
				if (repeated && !isComplete && (this.cachedTime != prevTime || force)) {
					
					/*
					  make sure children at the end/beginning of the timeline are rendered properly. If, for example, 
					  a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which
					  would get transated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there
					  could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So 
					  we need to push the timeline to the end (and/or beginning depending on its yoyo value).
					*/
					
					var forward:Boolean = Boolean(!this.yoyo || (_cyclesComplete % 2 == 0));
					var prevForward:Boolean = Boolean(!this.yoyo || (prevCycles % 2 == 0));
					var wrap:Boolean = Boolean(forward == prevForward);
					if (prevCycles > _cyclesComplete) {
						prevForward = !prevForward;
					}
					
					if (prevForward) {
						prevTime = forceChildrenToEnd(this.cachedDuration, suppressEvents);
						if (wrap) {
							prevTime = forceChildrenToBeginning(0, true);
						}
					} else {
						prevTime = forceChildrenToBeginning(0, suppressEvents);
						if (wrap) {
							prevTime = forceChildrenToEnd(this.cachedDuration, true);
						}
					}
					rendered = false;
				}
				
			}
			
			if (this.cachedTotalTime == prevTotalTime && !force) {
				return;
			} else if (!this.initted) {
				this.initted = true;
			}
			
			if (prevTotalTime == 0 && this.cachedTotalTime != 0 && !suppressEvents) {
				if (this.vars.onStart) {
					this.vars.onStart.apply(null, this.vars.onStartParams);
				}
				if (_dispatcher) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.START));
				}
			}
			
			if (rendered) {
				//already rendered, so ignore
			} else if (this.cachedTime - prevTime > 0) {
				tween = _firstChild;
				while (tween) {
					next = tween.nextNode; //record it here because the value could change after rendering...
					if (this.cachedPaused && !prevPaused) { //in case a tween pauses the timeline when rendering
						break;
					} else if (tween.active || (!tween.cachedPaused && tween.cachedStartTime <= this.cachedTime && !tween.gc)) {
						
						if (!tween.cachedReversed) {
							tween.renderTime((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
						} else {
							dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
							tween.renderTime(dur - ((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
						}
						
					}
					
					tween = next;
				}
			} else {
				tween = _lastChild;
				while (tween) {
					next = tween.prevNode; //record it here because the value could change after rendering...
					if (this.cachedPaused && !prevPaused) { //in case a tween pauses the timeline when rendering
						break;
					} else if (tween.active || (!tween.cachedPaused && tween.cachedStartTime <= prevTime && !tween.gc)) {
						
						if (!tween.cachedReversed) {
							tween.renderTime((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
						} else {
							dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
							tween.renderTime(dur - ((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
						}
						
					} 
					
					tween = next;
				}
			}
			if (_hasUpdate && !suppressEvents) {
				this.vars.onUpdate.apply(null, this.vars.onUpdateParams);
			}
			if (_hasUpdateListener && !suppressEvents) {
				_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.UPDATE));
			}
			if (repeated && !suppressEvents) {
				if (this.vars.onRepeat) {
					this.vars.onRepeat.apply(null, this.vars.onRepeatParams);
				}
				if (_dispatcher) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.REPEAT));
				}
			}
			if (isComplete && (prevStart == this.cachedStartTime || prevTimeScale != this.cachedTimeScale) && (totalDur >= this.totalDuration || this.cachedTime == 0)) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline) or if it added more tweens to the timeline, we shouldn't run complete() because it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would have called complete() if it was necessary at the new time. The only exception is the timeScale property.
				complete(true, suppressEvents);
			}
		}
		
		/**
		 * Forces the timeline to completion.
		 * 
		 * @param skipRender to skip rendering the final state of the timeline, set skipRender to true. 
		 * @param suppressEvents If true, no events or callbacks will be triggered for this render (like onComplete, onUpdate, onReverseComplete, etc.)
		 */
		override public function complete(skipRender:Boolean=false, suppressEvents:Boolean=false):void {
			super.complete(skipRender, suppressEvents);
			if (_dispatcher && !suppressEvents) {
				if (this.cachedReversed && this.cachedTotalTime == 0 && this.cachedDuration != 0) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.REVERSE_COMPLETE));
				} else {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.COMPLETE));
				}
			}
		}
		
		/**
		 * Returns the tweens/timelines that are currently active in the timeline.
		 * 
		 * @param nested determines whether or not tweens and/or timelines that are inside nested timelines should be returned. If you only want the ""top level"" tweens/timelines, set this to false.
		 * @param tweens determines whether or not tweens (TweenLite and TweenMax instances) should be included in the results
		 * @param timelines determines whether or not timelines (TimelineLite and TimelineMax instances) should be included in the results
		 * @return an Array of active tweens/timelines
		 */
		public function getActive(nested:Boolean=true, tweens:Boolean=true, timelines:Boolean=false):Array {
			var a:Array = [], all:Array = getChildren(nested, tweens, timelines), i:int;
			var l:int = all.length;
			var cnt:int = 0;
			for (i = 0; i < l; i += 1) {
				if (TweenCore(all[i]).active) {
					a[cnt++] = all[i];
				}
			}
			return a;
		}
		
		/** @inheritDoc **/
		override public function invalidate():void {
			_repeat = (this.vars.repeat) ? Number(this.vars.repeat) : 0;
			_repeatDelay = (this.vars.repeatDelay) ? Number(this.vars.repeatDelay) : 0;
			this.yoyo = Boolean(this.vars.yoyo == true);
			if (this.vars.onCompleteListener != null || this.vars.onUpdateListener != null || this.vars.onStartListener != null || this.vars.onRepeatListener != null || this.vars.onReverseCompleteListener != null) {
				initDispatcher();
			}
			setDirtyCache(true);
			super.invalidate();
		}
		
		/**
		 * Returns the next label (if any) that occurs AFTER the time parameter. It makes no difference
		 * if the timeline is reversed. A label that is positioned exactly at the same time as the <code>time</code>
		 * parameter will be ignored. 
		 * 
		 * @param time Time after which the label is searched for. If you do not pass a time in, the currentTime will be used. 
		 * @return Name of the label that is after the time passed to getLabelAfter()
		 */
		public function getLabelAfter(time:Number=NaN):String {
			if (!time && time != 0) { //faster than isNan()
				time = this.cachedTime;
			}
			var labels:Array = getLabelsArray();
			var l:int = labels.length;
			for (var i:int = 0; i < l; i += 1) {
				if (labels[i].time > time) {
					return labels[i].name;
				}
			}
			return null;
		}
		
		/**
		 * Returns the previous label (if any) that occurs BEFORE the time parameter. It makes no difference
		 * if the timeline is reversed. A label that is positioned exactly at the same time as the <code>time</code>
		 * parameter will be ignored. 
		 * 
		 * @param time Time before which the label is searched for. If you do not pass a time in, the currentTime will be used. 
		 * @return Name of the label that is before the time passed to getLabelBefore()
		 */
		public function getLabelBefore(time:Number=NaN):String {
			if (!time && time != 0) { //faster than isNan()
				time = this.cachedTime;
			}
			var labels:Array = getLabelsArray();
			var i:int = labels.length;
			while (--i > -1) {
				if (labels[i].time < time) {
					return labels[i].name;
				}
			}
			return null;
		}
		
		/** @private Returns an Array of label objects, each with a ""time"" and ""name"" property, in the order that they occur in the timeline. **/
		protected function getLabelsArray():Array {
			var a:Array = [];
			for (var p:String in _labels) {
				a[a.length] = {time:_labels[p], name:p};
			}
			a.sortOn(""time"", Array.NUMERIC);
			return a;
		}
		

//---- EVENT DISPATCHING ----------------------------------------------------------------------------------------------------------
		
		/** @private **/
		protected function initDispatcher():void {
			if (_dispatcher == null) {
				_dispatcher = new EventDispatcher(this);
			}
			if (this.vars.onStartListener is Function) {
				_dispatcher.addEventListener(TweenEvent.START, this.vars.onStartListener, false, 0, true);
			}
			if (this.vars.onUpdateListener is Function) {
				_dispatcher.addEventListener(TweenEvent.UPDATE, this.vars.onUpdateListener, false, 0, true);
				_hasUpdateListener = true;
			}
			if (this.vars.onCompleteListener is Function) {
				_dispatcher.addEventListener(TweenEvent.COMPLETE, this.vars.onCompleteListener, false, 0, true);
			}
			if (this.vars.onRepeatListener is Function) {
				_dispatcher.addEventListener(TweenEvent.REPEAT, this.vars.onRepeatListener, false, 0, true);
			}
			if (this.vars.onReverseCompleteListener is Function) {
				_dispatcher.addEventListener(TweenEvent.REVERSE_COMPLETE, this.vars.onReverseCompleteListener, false, 0, true);
			}
		}
		/** @private **/
		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
			if (_dispatcher == null) {
				initDispatcher();
			}
			if (type == TweenEvent.UPDATE) {
				_hasUpdateListener = true;
			}
			_dispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
		}
		/** @private **/
		public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void {
			if (_dispatcher != null) {
				_dispatcher.removeEventListener(type, listener, useCapture);
			}
		}
		/** @private **/
		public function hasEventListener(type:String):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.hasEventListener(type);
		}
		/** @private **/
		public function willTrigger(type:String):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.willTrigger(type);
		}
		/** @private **/
		public function dispatchEvent(e:Event):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.dispatchEvent(e);
		}
		
		
//---- GETTERS / SETTERS -------------------------------------------------------------------------------------------------------
		
		
		
		/** 
		 * Value between 0 and 1 indicating the overall progress of the timeline according to its <code>totalDuration</code> 
 		 * where 0 is at the beginning, 0.5 is halfway finished, and 1 is finished. <code>currentProgress</code>, 
 		 * by contrast, describes the progress according to the timeline's duration which does not
 		 * include repeats and repeatDelays. For example, if a TimelineMax instance is set 
 		 * to repeat once, at the end of the first cycle <code>totalProgress</code> would only be 0.5 
		 * whereas <code>currentProgress</code> would be 1. If you tracked both properties over the course of the 
		 * tween, you'd see <code>currentProgress</code> go from 0 to 1 twice (once for each cycle) in the same
		 * time it takes the <code>totalProgress</code> property to go from 0 to 1 once.
		 **/
		public function get totalProgress():Number {
			return this.cachedTotalTime / this.totalDuration;
		}
		
		public function set totalProgress(n:Number):void {
			setTotalTime(this.totalDuration * n, false);
		}
		
		/**
		 * Duration of the timeline in seconds (or frames for frames-based timelines) including any repeats
		 * or repeatDelays. ""duration"", by contrast, does NOT include repeats and repeatDelays.
		 **/
		override public function get totalDuration():Number {
			if (this.cacheIsDirty) {
				var temp:Number = super.totalDuration; //just forces refresh
				//Instead of Infinity, we use 999999999999 so that we can accommodate reverses.
				this.cachedTotalDuration = (_repeat == -1) ? 999999999999 : this.cachedDuration * (_repeat + 1) + (_repeatDelay * _repeat);
			}
			return this.cachedTotalDuration;
		}
		
		/** @private **/
		override public function set currentTime(n:Number):void {
			if (_cyclesComplete == 0) {
				setTotalTime(n, false);
			} else if (this.yoyo && (_cyclesComplete % 2 == 1)) {
				setTotalTime((this.duration - n) + (_cyclesComplete * (this.cachedDuration + _repeatDelay)), false);
			} else {
				setTotalTime(n + (_cyclesComplete * (this.duration + _repeatDelay)), false);
			}
		}
		
		/** Number of times that the timeline should repeat; -1 repeats indefinitely. **/
		public function get repeat():int {
			return _repeat;
		}
		
		public function set repeat(n:int):void {
			_repeat = n;
			setDirtyCache(true);
		}
		
		/** Amount of time in seconds (or frames for frames-based timelines) between repeats **/
		public function get repeatDelay():Number {
			return _repeatDelay;
		}
		
		public function set repeatDelay(n:Number):void {
			_repeatDelay = n;
			setDirtyCache(true);
		}
		
		/** The closest label that is at or before the current time. **/
		public function get currentLabel():String {
			return getLabelBefore(this.cachedTime + 0.00000001);
		}
		
	}
}",12121,False,2056.4616541058144,median
"/*

  PowerSaveTest.ino

  This test will turn on and off your display for two seconds.
  If the text ""power off"" is visible on your display, then power save mode
  does not work with your display.
  
  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7528_ERC16064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7528_ERC16064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


void setup(void) {
  u8g2.begin();
  u8g2.setFont(u8g2_font_6x10_tr);
}


void draw(const char *s)
{
  u8g2.firstPage();
  do {
    u8g2.drawStr(2,15,""PowerSaveTest"");    
    u8g2.drawStr(2,30,s);    
    u8g2.drawFrame(0,0,u8g2.getDisplayWidth(),u8g2.getDisplayHeight() );
  } while ( u8g2.nextPage() );
  delay(2000);
}

void loop(void) {
  u8g2.setPowerSave(0);
  draw(""power on / x"");
  u8g2.setPowerSave(1);
  draw(""power off / x"");
  u8g2.setPowerSave(0);
  draw(""power on / +"");
  u8g2.setPowerSave(1);
  draw(""power off / +"");
}

",16131,True,4903.104618301965,median
"/**
 * FlxControlHandler
 * -- Part of the Flixel Power Tools set
 * 
 * v1.8 Added isPressedUp/Down/Left/Right handlers
 * v1.7 Modified update function so gravity is applied constantly
 * v1.6 Thrust and Reverse complete, final few rotation bugs solved. Sounds hooked in for fire, jump, walk and thrust
 * v1.5 Full support for rotation with min/max angle limits
 * v1.4 Fixed bug in runFire causing fireRate to be ignored
 * v1.3 Major refactoring and lots of new enhancements
 * v1.2 First real version deployed to dev
 * v1.1 Updated for the Flixel 2.5 Plugin system
 * 
 * @version 1.8 - August 16th 2011
 * @link http://www.photonstorm.com
 * @author Richard Davey / Photon Storm
*/

package org.flixel.plugin.photonstorm 
{
	import flash.geom.Rectangle;
	import org.flixel.*;
	import flash.utils.getTimer;
	
	/**
	 * Makes controlling an FlxSprite with the keyboard a LOT easier and quicker to set-up!<br>
	 * Sometimes it's hard to know what values to set, especially if you want gravity, jumping, sliding, etc.<br>
	 * This class helps sort that - and adds some cool extra functionality too :)
	 * 
	 * TODO
	 * ----
	 * Allow to bind Fire Button to FlxWeapon
	 * Allow to enable multiple key sets. So cursors and WASD together
	 * Hot Keys
	 * Binding of sound effects to keys (seperate from setSounds? as those are event based)
	 * If moving diagonally compensate speed parameter (times x,y velocities by 0.707 or cos/sin(45))
	 * Specify animation frames to play based on velocity
	 * Variable gravity (based on height, the higher the stronger the effect)
	 */
	public class FlxControlHandler
	{
		//	Used by the FlxControl plugin
		public var enabled:Boolean = false;
		
		private var entity:FlxSprite = null;
		
		private var bounds:Rectangle;
		
		private var up:Boolean;
		private var down:Boolean;
		private var left:Boolean;
		private var right:Boolean;
		private var fire:Boolean;
		private var altFire:Boolean;
		private var jump:Boolean;
		private var altJump:Boolean;
		private var xFacing:Boolean;
		private var yFacing:Boolean;
		private var rotateAntiClockwise:Boolean;
		private var rotateClockwise:Boolean;
		
		private var upMoveSpeed:int;
		private var downMoveSpeed:int;
		private var leftMoveSpeed:int;
		private var rightMoveSpeed:int;
		private var thrustSpeed:int;
		private var reverseSpeed:int;
		
		//	Rotation
		private var thrustEnabled:Boolean;
		private var reverseEnabled:Boolean;
		private var isRotating:Boolean;
		private var antiClockwiseRotationSpeed:Number;
		private var clockwiseRotationSpeed:Number;
		private var enforceAngleLimits:Boolean;
		private var minAngle:int;
		private var maxAngle:int;
		private var capAngularVelocity:Boolean;
		
		private var xSpeedAdjust:Number = 0;
		private var ySpeedAdjust:Number = 0;
		
		private var gravityX:int = 0;
		private var gravityY:int = 0;
		
		private var fireRate:int; 			// The ms delay between firing when the key is held down
		private var nextFireTime:int; 		// The internal time when they can next fire
		private var lastFiredTime:int; 		// The internal time of when when they last fired
		private var fireKeyMode:uint;		// The fire key mode
		private var fireCallback:Function;	// A function to call every time they fire
		
		private var jumpHeight:int; 		// The pixel height amount they jump (drag and gravity also both influence this)
		private var jumpRate:int; 			// The ms delay between jumping when the key is held down
		private var jumpKeyMode:uint;		// The jump key mode
		private var nextJumpTime:int; 		// The internal time when they can next jump
		private var lastJumpTime:int; 		// The internal time of when when they last jumped
		private var jumpFromFallTime:int; 	// A short window of opportunity for them to jump having just fallen off the edge of a surface
		private var extraSurfaceTime:int; 	// Internal time of when they last collided with a valid jumpSurface
		private var jumpSurface:uint; 		// The surfaces from FlxObject they can jump from (i.e. FlxObject.FLOOR)
		private var jumpCallback:Function;	// A function to call every time they jump
		
		private var movement:int;
		private var stopping:int;
		private var rotation:int;
		private var rotationStopping:int;
		private var capVelocity:Boolean;
		
		private var hotkeys:Array;			// TODO
		
		private var upKey:String;
		private var downKey:String;
		private var leftKey:String;
		private var rightKey:String;
		private var fireKey:String;
		private var altFireKey:String;		// TODO
		private var jumpKey:String;
		private var altJumpKey:String;		// TODO
		private var antiClockwiseKey:String;
		private var clockwiseKey:String;
		private var thrustKey:String;
		private var reverseKey:String;
		
		//	Sounds
		private var jumpSound:FlxSound = null;
		private var fireSound:FlxSound = null;
		private var walkSound:FlxSound = null;
		private var thrustSound:FlxSound = null;
		
		//	Helpers
		public var isPressedUp:Boolean = false;
		public var isPressedDown:Boolean = false;
		public var isPressedLeft:Boolean = false;
		public var isPressedRight:Boolean = false;
		
		/**
		 * The ""Instant"" Movement Type means the sprite will move at maximum speed instantly, and will not ""accelerate"" (or speed-up) before reaching that speed.
		 */
		public static const MOVEMENT_INSTANT:int = 0;
		/**
		 * The ""Accelerates"" Movement Type means the sprite will accelerate until it reaches maximum speed.
		 */
		public static const MOVEMENT_ACCELERATES:int = 1;
		/**
		 * The ""Instant"" Stopping Type means the sprite will stop immediately when no direction keys are being pressed, there will be no deceleration.
		 */
		public static const STOPPING_INSTANT:int = 0;
		/**
		 * The ""Decelerates"" Stopping Type means the sprite will start decelerating when no direction keys are being pressed. Deceleration continues until the speed reaches zero.
		 */
		public static const STOPPING_DECELERATES:int = 1;
		/**
		 * The ""Never"" Stopping Type means the sprite will never decelerate, any speed built up will be carried on and never reduce.
		 */
		public static const STOPPING_NEVER:int = 2;
		
		/**
		 * The ""Instant"" Movement Type means the sprite will rotate at maximum speed instantly, and will not ""accelerate"" (or speed-up) before reaching that speed.
		 */
		public static const ROTATION_INSTANT:int = 0;
		/**
		 * The ""Accelerates"" Rotaton Type means the sprite will accelerate until it reaches maximum rotation speed.
		 */
		public static const ROTATION_ACCELERATES:int = 1;
		/**
		 * The ""Instant"" Stopping Type means the sprite will stop rotating immediately when no rotation keys are being pressed, there will be no deceleration.
		 */
		public static const ROTATION_STOPPING_INSTANT:int = 0;
		/**
		 * The ""Decelerates"" Stopping Type means the sprite will start decelerating when no rotation keys are being pressed. Deceleration continues until rotation speed reaches zero.
		 */
		public static const ROTATION_STOPPING_DECELERATES:int = 1;
		/**
		 * The ""Never"" Stopping Type means the sprite will never decelerate, any speed built up will be carried on and never reduce.
		 */
		public static const ROTATION_STOPPING_NEVER:int = 2;
		
		/**
		 * This keymode fires for as long as the key is held down
		 */
		public static const KEYMODE_PRESSED:int = 0;
		
		/**
		 * This keyboard fires when the key has just been pressed down, and not again until it is released and re-pressed
		 */
		public static const KEYMODE_JUST_DOWN:int = 1;
		
		/**
		 * This keyboard fires only when the key has been pressed and then released again
		 */
		public static const KEYMODE_RELEASED:int = 2;
		
		/**
		 * Sets the FlxSprite to be controlled by this class, and defines the initial movement and stopping types.<br>
		 * After creating an instance of this class you should call setMovementSpeed, and one of the enableXControl functions if you need more than basic cursors.
		 * 
		 * @param	source			The FlxSprite you want this class to control. It can only control one FlxSprite at once.
		 * @param	movementType	Set to either MOVEMENT_INSTANT or MOVEMENT_ACCELERATES
		 * @param	stoppingType	Set to STOPPING_INSTANT, STOPPING_DECELERATES or STOPPING_NEVER
		 * @param	updateFacing	If true it sets the FlxSprite.facing value to the direction pressed (default false)
		 * @param	enableArrowKeys	If true it will enable all arrow keys (default) - see setCursorControl for more fine-grained control
		 * 
		 * @see		setMovementSpeed
		 */
		public function FlxControlHandler(source:FlxSprite, movementType:int, stoppingType:int, updateFacing:Boolean = false, enableArrowKeys:Boolean = true)
		{
			entity = source;
			
			movement = movementType;
			stopping = stoppingType;
			
			xFacing = updateFacing;
			yFacing = updateFacing;
			
			up = false;
			down = false;
			left = false;
			right = false;
			
			thrustEnabled = false;
			isRotating = false;
			enforceAngleLimits = false;
			rotation = ROTATION_INSTANT;
			rotationStopping = ROTATION_STOPPING_INSTANT;
			
			if (enableArrowKeys)
			{
				setCursorControl();
			}
			
			enabled = true;
		}
		
		/**
		 * Set the speed at which the sprite will move when a direction key is pressed.<br>
		 * All values are given in pixels per second. So an xSpeed of 100 would move the sprite 100 pixels in 1 second (1000ms)<br>
		 * Due to the nature of the internal Flash timer this amount is not 100% accurate and will vary above/below the desired distance by a few pixels.<br>
		 * 
		 * If you need different speed values for left/right or up/down then use setAdvancedMovementSpeed
		 * 
		 * @param	xSpeed			The speed in pixels per second in which the sprite will move/accelerate horizontally
		 * @param	ySpeed			The speed in pixels per second in which the sprite will move/accelerate vertically
		 * @param	xSpeedMax		The maximum speed in pixels per second in which the sprite can move horizontally
		 * @param	ySpeedMax		The maximum speed in pixels per second in which the sprite can move vertically
		 * @param	xDeceleration	A deceleration speed in pixels per second to apply to the sprites horizontal movement (default 0)
		 * @param	yDeceleration	A deceleration speed in pixels per second to apply to the sprites vertical movement (default 0)
		 */
		public function setMovementSpeed(xSpeed:uint, ySpeed:uint, xSpeedMax:uint, ySpeedMax:uint, xDeceleration:uint = 0, yDeceleration:uint = 0):void
		{
			leftMoveSpeed = -xSpeed;
			rightMoveSpeed = xSpeed;
			upMoveSpeed = -ySpeed;
			downMoveSpeed = ySpeed;
			
			setMaximumSpeed(xSpeedMax, ySpeedMax);
			setDeceleration(xDeceleration, yDeceleration);
		}
		
		/**
		 * If you know you need the same value for the acceleration, maximum speeds and (optionally) deceleration then this is a quick way to set them.
		 * 
		 * @param	speed			The speed in pixels per second in which the sprite will move/accelerate/decelerate
		 * @param	acceleration	If true it will set the speed value as the deceleration value (default) false will leave deceleration disabled
		 */
		public function setStandardSpeed(speed:uint, acceleration:Boolean = true):void
		{
			if (acceleration)
			{
				setMovementSpeed(speed, speed, speed, speed, speed, speed);
			}
			else
			{
				setMovementSpeed(speed, speed, speed, speed);
			}
		}
		
		/**
		 * Set the speed at which the sprite will move when a direction key is pressed.<br>
		 * All values are given in pixels per second. So an xSpeed of 100 would move the sprite 100 pixels in 1 second (1000ms)<br>
		 * Due to the nature of the internal Flash timer this amount is not 100% accurate and will vary above/below the desired distance by a few pixels.<br>
		 * 
		 * If you don't need different speed values for every direction on its own then use setMovementSpeed
		 * 
		 * @param	leftSpeed		The speed in pixels per second in which the sprite will move/accelerate to the left
		 * @param	rightSpeed		The speed in pixels per second in which the sprite will move/accelerate to the right
		 * @param	upSpeed			The speed in pixels per second in which the sprite will move/accelerate up
		 * @param	downSpeed		The speed in pixels per second in which the sprite will move/accelerate down
		 * @param	xSpeedMax		The maximum speed in pixels per second in which the sprite can move horizontally
		 * @param	ySpeedMax		The maximum speed in pixels per second in which the sprite can move vertically
		 * @param	xDeceleration	Deceleration speed in pixels per second to apply to the sprites horizontal movement (default 0)
		 * @param	yDeceleration	Deceleration speed in pixels per second to apply to the sprites vertical movement (default 0)
		 */
		public function setAdvancedMovementSpeed(leftSpeed:uint, rightSpeed:uint, upSpeed:uint, downSpeed:uint, xSpeedMax:uint, ySpeedMax:uint, xDeceleration:uint = 0, yDeceleration:uint = 0):void
		{
			leftMoveSpeed = -leftSpeed;
			rightMoveSpeed = rightSpeed;
			upMoveSpeed = -upSpeed;
			downMoveSpeed = downSpeed;
			
			setMaximumSpeed(xSpeedMax, ySpeedMax);
			setDeceleration(xDeceleration, yDeceleration);
		}
		
		/**
		 * Set the speed at which the sprite will rotate when a direction key is pressed.<br>
		 * Use this in combination with setMovementSpeed to create a Thrust like movement system.<br>
		 * All values are given in pixels per second. So an xSpeed of 100 would rotate the sprite 100 pixels in 1 second (1000ms)<br>
		 * Due to the nature of the internal Flash timer this amount is not 100% accurate and will vary above/below the desired distance by a few pixels.<br>
		 */
		public function setRotationSpeed(antiClockwiseSpeed:Number, clockwiseSpeed:Number, speedMax:Number, deceleration:Number):void
		{
			antiClockwiseRotationSpeed = -antiClockwiseSpeed;
			clockwiseRotationSpeed = clockwiseSpeed;
			
			setRotationKeys();
			setMaximumRotationSpeed(speedMax);
			setRotationDeceleration(deceleration);
		}
		
		/**
		 * 
		 * 
		 * @param	rotationType
		 * @param	stoppingType
		 */
		public function setRotationType(rotationType:int, stoppingType:int):void
		{
			rotation = rotationType;
			rotationStopping = stoppingType;
		}
		
		/**
		 * Sets the maximum speed (in pixels per second) that the FlxSprite can rotate.<br>
		 * When the FlxSprite is accelerating (movement type MOVEMENT_ACCELERATES) its speed won't increase above this value.<br>
		 * However Flixel allows the velocity of an FlxSprite to be set to anything. So if you'd like to check the value and restrain it, then enable ""limitVelocity"".
		 * 
		 * @param	speed			The maximum speed in pixels per second in which the sprite can rotate
		 * @param	limitVelocity	If true the angular velocity of the FlxSprite will be checked and kept within the limit. If false it can be set to anything.
		 */
		public function setMaximumRotationSpeed(speed:Number, limitVelocity:Boolean = true):void
		{
			entity.maxAngular = speed;
			
			capAngularVelocity = limitVelocity;
		}
		
		/**
		 * Deceleration is a speed (in pixels per second) that is applied to the sprite if stopping type is ""DECELERATES"" and if no rotation is taking place.<br>
		 * The velocity of the sprite will be reduced until it reaches zero.
		 * 
		 * @param	speed		The speed in pixels per second at which the sprite will have its angular rotation speed decreased
		 */
		public function setRotationDeceleration(speed:Number):void
		{
			entity.angularDrag = speed;
		}
		
		/**
		 * Set minimum and maximum angle limits that the Sprite won't be able to rotate beyond.<br>
		 * Values must be between -180 and +180. 0 is pointing right, 90 down, 180 left, -90 up.
		 * 
		 * @param	minimumAngle	Minimum angle below which the sprite cannot rotate (must be -180 or above)
		 * @param	maximumAngle	Maximum angle above which the sprite cannot rotate (must be 180 or below)
		 */
		public function setRotationLimits(minimumAngle:int, maximumAngle:int):void
		{
			if (minimumAngle > maximumAngle || minimumAngle < -180 || maximumAngle > 180)
			{
				throw new Error(""FlxControlHandler setRotationLimits: Invalid Minimum / Maximum angle"");
			}
			else
			{
				enforceAngleLimits = true;
				minAngle = minimumAngle;
				maxAngle = maximumAngle;
			}
		}
		
		/**
		 * Disables rotation limits set in place by setRotationLimits()
		 */
		public function disableRotationLimits():void
		{
			enforceAngleLimits = false;
		}
		
		/**
		 * Set which keys will rotate the sprite. The speed of rotation is set in setRotationSpeed.
		 * 
		 * @param	leftRight				Use the LEFT and RIGHT arrow keys for anti-clockwise and clockwise rotation respectively.
		 * @param	upDown					Use the UP and DOWN arrow keys for anti-clockwise and clockwise rotation respectively.
		 * @param	customAntiClockwise		The String value of your own key to use for anti-clockwise rotation (as taken from org.flixel.system.input.Keyboard)
		 * @param	customClockwise			The String value of your own key to use for clockwise rotation (as taken from org.flixel.system.input.Keyboard)
		 */
		public function setRotationKeys(leftRight:Boolean = true, upDown:Boolean = false, customAntiClockwise:String = """", customClockwise:String = """"):void
		{
			isRotating = true;
			rotateAntiClockwise = true;
			rotateClockwise = true;
			antiClockwiseKey = ""LEFT"";
			clockwiseKey = ""RIGHT"";

			if (upDown == true)
			{
				antiClockwiseKey = ""UP"";
				clockwiseKey = ""DOWN"";
			}
			
			if (customAntiClockwise != """" && customClockwise != """")
			{
				antiClockwiseKey = customAntiClockwise;
				clockwiseKey = customClockwise;
			}
		}
		
		/**
		 * If you want to enable a Thrust like motion for your sprite use this to set the speed and keys.<br>
		 * This is usually used in conjunction with Rotation and it will over-ride anything already defined in setMovementSpeed.
		 * 
		 * @param	thrustKey		Specify the key String (as taken from org.flixel.system.input.Keyboard) to use for the Thrust action
		 * @param	thrustSpeed		The speed in pixels per second which the sprite will move. Acceleration or Instant movement is determined by the Movement Type.
		 * @param	reverseKey		If you want to be able to reverse, set the key string as taken from org.flixel.system.input.Keyboard (defaults to null).
		 * @param	reverseSpeed	The speed in pixels per second which the sprite will reverse. Acceleration or Instant movement is determined by the Movement Type.
		 */
		public function setThrust(thrustKey:String, thrustSpeed:Number, reverseKey:String = null, reverseSpeed:Number = 0):void
		{
			thrustEnabled = false;
			reverseEnabled = false;
			
			if (thrustKey)
			{
				this.thrustKey = thrustKey;
				this.thrustSpeed = thrustSpeed;
				thrustEnabled = true;
			}
			
			if (reverseKey)
			{
				this.reverseKey = reverseKey;
				this.reverseSpeed = reverseSpeed;
				reverseEnabled = true;
			}
		}
		
		/**
		 * Sets the maximum speed (in pixels per second) that the FlxSprite can move. You can set the horizontal and vertical speeds independantly.<br>
		 * When the FlxSprite is accelerating (movement type MOVEMENT_ACCELERATES) its speed won't increase above this value.<br>
		 * However Flixel allows the velocity of an FlxSprite to be set to anything. So if you'd like to check the value and restrain it, then enable ""limitVelocity"".
		 * 
		 * @param	xSpeed			The maximum speed in pixels per second in which the sprite can move horizontally
		 * @param	ySpeed			The maximum speed in pixels per second in which the sprite can move vertically
		 * @param	limitVelocity	If true the velocity of the FlxSprite will be checked and kept within the limit. If false it can be set to anything.
		 */
		public function setMaximumSpeed(xSpeed:uint, ySpeed:uint, limitVelocity:Boolean = true):void
		{
			entity.maxVelocity.x = xSpeed;
			entity.maxVelocity.y = ySpeed;
			
			capVelocity = limitVelocity;
		}
		
		/**
		 * Deceleration is a speed (in pixels per second) that is applied to the sprite if stopping type is ""DECELERATES"" and if no acceleration is taking place.<br>
		 * The velocity of the sprite will be reduced until it reaches zero, and can be configured separately per axis.
		 * 
		 * @param	xSpeed		The speed in pixels per second at which the sprite will have its horizontal speed decreased
		 * @param	ySpeed		The speed in pixels per second at which the sprite will have its vertical speed decreased
		 */
		public function setDeceleration(xSpeed:uint, ySpeed:uint):void
		{
			entity.drag.x = xSpeed;
			entity.drag.y = ySpeed;
		}
		
		/**
		 * Gravity can be applied to the sprite, pulling it in any direction.<br>
		 * Gravity is given in pixels per second and is applied as acceleration. The speed the sprite reaches under gravity will never exceed the Maximum Movement Speeds set.<br>
		 * If you don't want gravity for a specific direction pass a value of zero.
		 * 
		 * @param	xForce	A positive value applies gravity dragging the sprite to the right. A negative value drags the sprite to the left. Zero disables horizontal gravity.
		 * @param	yForce	A positive value applies gravity dragging the sprite down. A negative value drags the sprite up. Zero disables vertical gravity.
		 */
		public function setGravity(xForce:int, yForce:int):void
		{
			gravityX = xForce;
			gravityY = yForce;
			
			entity.acceleration.x = gravityX;
			entity.acceleration.y = gravityY;
		}
		
		/**
		 * Switches the gravity applied to the sprite. If gravity was +400 Y (pulling them down) this will swap it to -400 Y (pulling them up)<br>
		 * To reset call flipGravity again
		 */
		public function flipGravity():void
		{
			if (gravityX && gravityX != 0)
			{
				gravityX = -gravityX;
				entity.acceleration.x = gravityX;
			}
			
			if (gravityY && gravityY != 0)
			{
				gravityY = -gravityY;
				entity.acceleration.y = gravityY;
			}
		}
		
		/**
		 * TODO
		 * 
		 * @param	xFactor
		 * @param	yFactor
		 */
		public function speedUp(xFactor:Number, yFactor:Number):void
		{
		}
		
		/**
		 * TODO
		 * 
		 * @param	xFactor
		 * @param	yFactor
		 */
		public function slowDown(xFactor:Number, yFactor:Number):void
		{
		}
		
		/**
		 * TODO
		 * 
		 * @param	xFactor
		 * @param	yFactor
		 */
		public function resetSpeeds(resetX:Boolean = true, resetY:Boolean = true):void
		{
			if (resetX)
			{
				xSpeedAdjust = 0;
			}
			
			if (resetY)
			{
				ySpeedAdjust = 0;
			}
		}
		
		/**
		 * Creates a new Hot Key, which can be bound to any function you specify (such as ""swap weapon"", ""quit"", etc)
		 * 
		 * @param	key			The key to use as the hot key (String from org.flixel.system.input.Keyboard, i.e. ""SPACE"", ""CONTROL"", ""Q"", etc)
		 * @param	callback	The function to call when the key is pressed
		 * @param	keymode		The keymode that will trigger the callback, either KEYMODE_PRESSED, KEYMODE_JUST_DOWN or KEYMODE_RELEASED
		 */
		public function addHotKey(key:String, callback:Function, keymode:int):void
		{
			
		}
		
		/**
		 * Removes a previously defined hot key
		 * 
		 * @param	key		The key to use as the hot key (String from org.flixel.system.input.Keyboard, i.e. ""SPACE"", ""CONTROL"", ""Q"", etc)
		 * @return	true if the key was found and removed, false if the key couldn't be found
		 */
		public function removeHotKey(key:String):Boolean
		{
			return true;
		}
		
		/**
		 * Set sound effects for the movement events jumping, firing, walking and thrust.
		 * 
		 * @param	jump	The FlxSound to play when the user jumps
		 * @param	fire	The FlxSound to play when the user fires
		 * @param	walk	The FlxSound to play when the user walks
		 * @param	thrust	The FlxSound to play when the user thrusts
		 */
		public function setSounds(jump:FlxSound = null, fire:FlxSound = null, walk:FlxSound = null, thrust:FlxSound = null):void
		{
			if (jump)
			{
				jumpSound = jump;
			}
			
			if (fire)
			{
				fireSound = fire;
			}
			
			if (walk)
			{
				walkSound = walk;
			}
			
			if (thrust)
			{
				thrustSound = thrust;
			}
		}
		
		/**
		 * Enable a fire button
		 * 
		 * @param	key				The key to use as the fire button (String from org.flixel.system.input.Keyboard, i.e. ""SPACE"", ""CONTROL"")
		 * @param	keymode			The FlxControlHandler KEYMODE value (KEYMODE_PRESSED, KEYMODE_JUST_DOWN, KEYMODE_RELEASED)
		 * @param	repeatDelay		Time delay in ms between which the fire action can repeat (0 means instant, 250 would allow it to fire approx. 4 times per second)
		 * @param	callback		A user defined function to call when it fires
		 * @param	altKey			Specify an alternative fire key that works AS WELL AS the primary fire key (TODO)
		 */
		public function setFireButton(key:String, keymode:uint, repeatDelay:uint, callback:Function, altKey:String = """"):void
		{
			fireKey = key;
			fireKeyMode = keymode;
			fireRate = repeatDelay;
			fireCallback = callback;
			
			if (altKey != """")
			{
				altFireKey = altKey;
			}
			
			fire = true;
		}
		
		/**
		 * Enable a jump button
		 * 
		 * @param	key				The key to use as the jump button (String from org.flixel.system.input.Keyboard, i.e. ""SPACE"", ""CONTROL"")
		 * @param	keymode			The FlxControlHandler KEYMODE value (KEYMODE_PRESSED, KEYMODE_JUST_DOWN, KEYMODE_RELEASED)
		 * @param	height			The height in pixels/sec that the Sprite will attempt to jump (gravity and acceleration can influence this actual height obtained)
		 * @param	surface			A bitwise combination of all valid surfaces the Sprite can jump off (from FlxObject, such as FlxObject.FLOOR)
		 * @param	repeatDelay		Time delay in ms between which the jumping can repeat (250 would be 4 times per second)
		 * @param	jumpFromFall	A time in ms that allows the Sprite to still jump even if it's just fallen off a platform, if still within ths time limit
		 * @param	callback		A user defined function to call when the Sprite jumps
		 * @param	altKey			Specify an alternative jump key that works AS WELL AS the primary jump key (TODO)
		 */
		public function setJumpButton(key:String, keymode:uint, height:int, surface:int, repeatDelay:uint = 250, jumpFromFall:int = 0, callback:Function = null, altKey:String = """"):void
		{
			jumpKey = key;
			jumpKeyMode = keymode;
			jumpHeight = height;
			jumpSurface = surface;
			jumpRate = repeatDelay;
			jumpFromFallTime = jumpFromFall;
			jumpCallback = callback;
			
			if (altKey != """")
			{
				altJumpKey = altKey;
			}
			
			jump = true;
		}
		
		/**
		 * Limits the sprite to only be allowed within this rectangle. If its x/y coordinates go outside it will be repositioned back inside.<br>
		 * Coordinates should be given in GAME WORLD pixel values (not screen value, although often they are the two same things)
		 * 
		 * @param	x		The x coordinate of the top left corner of the area (in game world pixels)
		 * @param	y		The y coordinate of the top left corner of the area (in game world pixels)
		 * @param	width	The width of the area (in pixels)
		 * @param	height	The height of the area (in pixels)
		 */
		public function setBounds(x:int, y:int, width:uint, height:uint):void
		{
			bounds = new Rectangle(x, y, width, height);
		}
		
		/**
		 * Clears any previously set sprite bounds
		 */
		public function removeBounds():void
		{
			bounds = null;
		}
		
		private function moveUp():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(upKey))
			{
				move = true;
				isPressedUp = true;
				
				if (yFacing)
				{
					entity.facing = FlxObject.UP;
				}
				
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.y = upMoveSpeed;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.y = upMoveSpeed;
				}
				
				if (bounds && entity.y < bounds.top)
				{
					entity.y = bounds.top;
				}
			}
			
			return move;
		}
		
		private function moveDown():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(downKey))
			{
				move = true;
				isPressedDown = true;
				
				if (yFacing)
				{
					entity.facing = FlxObject.DOWN;
				}
				
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.y = downMoveSpeed;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.y = downMoveSpeed;
				}
				
				if (bounds && entity.y > bounds.bottom)
				{
					entity.y = bounds.bottom;
				}
				
			}
			
			return move;
		}
		
		private function moveLeft():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(leftKey))
			{
				move = true;
				isPressedLeft = true;
				
				if (xFacing)
				{
					entity.facing = FlxObject.LEFT;
				}
				
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.x = leftMoveSpeed;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.x = leftMoveSpeed;
				}
				
				if (bounds && entity.x < bounds.x)
				{
					entity.x = bounds.x;
				}
			}
			
			return move;
		}
		
		private function moveRight():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(rightKey))
			{
				move = true;
				isPressedRight = true;
				
				if (xFacing)
				{
					entity.facing = FlxObject.RIGHT;
				}
				
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.x = rightMoveSpeed;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.x = rightMoveSpeed;
				}
				
				if (bounds && entity.x > bounds.right)
				{
					entity.x = bounds.right;
				}
			}
			
			return move;
		}
		
		private function moveAntiClockwise():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(antiClockwiseKey))
			{
				move = true;
				
				if (rotation == ROTATION_INSTANT)
				{
					entity.angularVelocity = antiClockwiseRotationSpeed;
				}
				else if (rotation == ROTATION_ACCELERATES)
				{
					entity.angularAcceleration = antiClockwiseRotationSpeed;
				}
				
				//  - Not quite there yet given the way Flixel can rotate to any valid int angle!
				if (enforceAngleLimits)
				{
					//entity.angle = FlxMath.angleLimit(entity.angle, minAngle, maxAngle);
				}
			}
			
			return move;
		}
		
		private function moveClockwise():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(clockwiseKey))
			{
				move = true;
				
				if (rotation == ROTATION_INSTANT)
				{
					entity.angularVelocity = clockwiseRotationSpeed;
				}
				else if (rotation == ROTATION_ACCELERATES)
				{
					entity.angularAcceleration = clockwiseRotationSpeed;
				}
				
				//  - Not quite there yet given the way Flixel can rotate to any valid int angle!
				if (enforceAngleLimits)
				{
					//entity.angle = FlxMath.angleLimit(entity.angle, minAngle, maxAngle);
				}
			}
			
			return move;
		}
		
		private function moveThrust():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(thrustKey))
			{
				move = true;
				
				var motion:FlxPoint = FlxVelocity.velocityFromAngle(entity.angle, thrustSpeed);
				
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.x = motion.x;
					entity.velocity.y = motion.y;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.x = motion.x;
					entity.acceleration.y = motion.y;
				}
				
				if (bounds && entity.x < bounds.x)
				{
					entity.x = bounds.x;
				}
			}
			
			if (move && thrustSound)
			{
				thrustSound.play(false);
			}
			
			return move;
		}
		
		private function moveReverse():Boolean
		{
			var move:Boolean = false;
			
			if (FlxG.keys.pressed(reverseKey))
			{
				move = true;
				
				var motion:FlxPoint = FlxVelocity.velocityFromAngle(entity.angle, reverseSpeed);
				
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.x = -motion.x;
					entity.velocity.y = -motion.y;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.x = -motion.x;
					entity.acceleration.y = -motion.y;
				}
				
				if (bounds && entity.x < bounds.x)
				{
					entity.x = bounds.x;
				}
			}
			
			return move;
		}
		
		private function runFire():Boolean
		{
			var fired:Boolean = false;
			
			//	0 = Pressed
			//	1 = Just Down
			//	2 = Just Released
			if ((fireKeyMode == 0 && FlxG.keys.pressed(fireKey)) || (fireKeyMode == 1 && FlxG.keys.justPressed(fireKey)) || (fireKeyMode == 2 && FlxG.keys.justReleased(fireKey)))
			{
				if (fireRate > 0)
				{
					if (getTimer() > nextFireTime)
					{
						lastFiredTime = getTimer();
						
						fireCallback.call();
						
						fired = true;
						
						nextFireTime = lastFiredTime + fireRate;
					}
				}
				else
				{
					lastFiredTime = getTimer();
					
					fireCallback.call();
					
					fired = true;
				}
			}
			
			if (fired && fireSound)
			{
				fireSound.play(true);
			}
			
			return fired;
		}
		
		private function runJump():Boolean
		{
			var jumped:Boolean = false;
			
			//	This should be called regardless if they've pressed jump or not
			if (entity.isTouching(jumpSurface))
			{
				extraSurfaceTime = getTimer() + jumpFromFallTime;
			}
			
			if ((jumpKeyMode == KEYMODE_PRESSED && FlxG.keys.pressed(jumpKey)) || (jumpKeyMode == KEYMODE_JUST_DOWN && FlxG.keys.justPressed(jumpKey)) || (jumpKeyMode == KEYMODE_RELEASED && FlxG.keys.justReleased(jumpKey)))
			{
				//	Sprite not touching a valid jump surface
				if (entity.isTouching(jumpSurface) == false)
				{
					//	They've run out of time to jump
					if (getTimer() > extraSurfaceTime)
					{
						return jumped;
					}
					else
					{
						//	Still within the fall-jump window of time, but have jumped recently
						if (lastJumpTime > (extraSurfaceTime - jumpFromFallTime))
						{
							return jumped;
						}
					}
					
					//	If there is a jump repeat rate set and we're still less than it then return
					if (getTimer() < nextJumpTime)
					{
						return jumped;
					}
				}
				else
				{
					//	If there is a jump repeat rate set and we're still less than it then return
					if (getTimer() < nextJumpTime)
					{
						return jumped;
					}
				}
				
				if (gravityY > 0)
				{
					//	Gravity is pulling them down to earth, so they are jumping up (negative)
					entity.velocity.y = -jumpHeight;
				}
				else
				{
					//	Gravity is pulling them up, so they are jumping down (positive)
					entity.velocity.y = jumpHeight;
				}
				
				if (jumpCallback is Function)
				{
					jumpCallback.call();
				}
				
				lastJumpTime = getTimer();
				nextJumpTime = lastJumpTime + jumpRate;
					
				jumped = true;
			}
			
			if (jumped && jumpSound)
			{
				jumpSound.play(true);
			}
			
			return jumped;
		}
		
		/**
		 * Called by the FlxControl plugin
		 */
		public function update():void
		{
			if (entity == null)
			{
				return;
			}
			
			//	Reset the helper booleans
			isPressedUp = false;
			isPressedDown = false;
			isPressedLeft = false;
			isPressedRight = false;
			
			if (stopping == STOPPING_INSTANT)
			{
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.x = 0;
					entity.velocity.y = 0;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					entity.acceleration.x = 0;
					entity.acceleration.y = 0;
				}
			}
			else if (stopping == STOPPING_DECELERATES)
			{
				if (movement == MOVEMENT_INSTANT)
				{
					entity.velocity.x = 0;
					entity.velocity.y = 0;
				}
				else if (movement == MOVEMENT_ACCELERATES)
				{
					//	By default these are zero anyway, so it's safe to set like this
					entity.acceleration.x = gravityX;
					entity.acceleration.y = gravityY;
				}
			}
			
			//	Rotation
			if (isRotating)
			{
				if (rotationStopping == ROTATION_STOPPING_INSTANT)
				{
					if (rotation == ROTATION_INSTANT)
					{
						entity.angularVelocity = 0;
					}
					else if (rotation == ROTATION_ACCELERATES)
					{
						entity.angularAcceleration = 0;
					}
				}
				else if (rotationStopping == ROTATION_STOPPING_DECELERATES)
				{
					if (rotation == ROTATION_INSTANT)
					{
						entity.angularVelocity = 0;
					}
				}
				
				var hasRotatedAntiClockwise:Boolean = false;
				var hasRotatedClockwise:Boolean = false;
				
				hasRotatedAntiClockwise = moveAntiClockwise();
				
				if (hasRotatedAntiClockwise == false)
				{
					hasRotatedClockwise = moveClockwise();
				}
				
				if (rotationStopping == ROTATION_STOPPING_DECELERATES)
				{
					if (rotation == ROTATION_ACCELERATES && hasRotatedAntiClockwise == false && hasRotatedClockwise == false)
					{
						entity.angularAcceleration = 0;
					}
				}
				
				//	If they have got instant stopping with acceleration and are NOT pressing a key, then stop the rotation. Otherwise we let it carry on
				if (rotationStopping == ROTATION_STOPPING_INSTANT && rotation == ROTATION_ACCELERATES && hasRotatedAntiClockwise == false && hasRotatedClockwise == false)
				{
					entity.angularVelocity = 0;
					entity.angularAcceleration = 0;
				}
			}
			
			//	Thrust
			if (thrustEnabled || reverseEnabled)
			{
				var moved:Boolean = false;
				
				if (thrustEnabled)
				{
					moved = moveThrust();
				}
				
				if (moved == false && reverseEnabled)
				{
					moved = moveReverse();
				}
			}
			else
			{
				var movedX:Boolean = false;
				var movedY:Boolean = false;
				
				if (up)
				{
					movedY = moveUp();
				}
				
				if (down && movedY == false)
				{
					movedY = moveDown();
				}
				
				if (left)
				{
					movedX = moveLeft();
				}
				
				if (right && movedX == false)
				{
					movedX = moveRight();
				}
			}
			
			if (fire)
			{
				runFire();
			}
			
			if (jump)
			{
				runJump();
			}
			
			if (capVelocity)
			{
				if (entity.velocity.x > entity.maxVelocity.x)
				{
					entity.velocity.x = entity.maxVelocity.x;
				}
				
				if (entity.velocity.y > entity.maxVelocity.y)
				{
					entity.velocity.y = entity.maxVelocity.y;
				}
			}
			
			if (walkSound)
			{
				if ((movement == MOVEMENT_INSTANT && entity.velocity.x != 0) || (movement == MOVEMENT_ACCELERATES && entity.acceleration.x != 0))
				{
					walkSound.play(false);
				}
				else
				{
					walkSound.stop();
				}
			}
		}
		
		/**
		 * Sets Custom Key controls. Useful if none of the pre-defined sets work. All String values should be taken from org.flixel.system.input.Keyboard
		 * Pass a blank (empty) String to disable that key from being checked.
		 * 
		 * @param	customUpKey		The String to use for the Up key.
		 * @param	customDownKey	The String to use for the Down key.
		 * @param	customLeftKey	The String to use for the Left key.
		 * @param	customRightKey	The String to use for the Right key.
		 */
		public function setCustomKeys(customUpKey:String, customDownKey:String, customLeftKey:String, customRightKey:String):void
		{
			if (customUpKey != """")
			{
				up = true;
				upKey = customUpKey;
			}
			
			if (customDownKey != """")
			{
				down = true;
				downKey = customDownKey;
			}
			
			if (customLeftKey != """")
			{
				left = true;
				leftKey = customLeftKey;
			}
			
			if (customRightKey != """")
			{
				right = true;
				rightKey = customRightKey;
			}
		}
		
		/**
		 * Enables Cursor/Arrow Key controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the UP key
		 * @param	allowDown	Enable the DOWN key
		 * @param	allowLeft	Enable the LEFT key
		 * @param	allowRight	Enable the RIGHT key
		 */
		public function setCursorControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""UP"";
			downKey = ""DOWN"";
			leftKey = ""LEFT"";
			rightKey = ""RIGHT"";
		}
		
		/**
		 * Enables WASD controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (W) key
		 * @param	allowDown	Enable the down (S) key
		 * @param	allowLeft	Enable the left (A) key
		 * @param	allowRight	Enable the right (D) key
		 */
		public function setWASDControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""W"";
			downKey = ""S"";
			leftKey = ""A"";
			rightKey = ""D"";
		}
		
		/**
		 * Enables ESDF (home row) controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (E) key
		 * @param	allowDown	Enable the down (D) key
		 * @param	allowLeft	Enable the left (S) key
		 * @param	allowRight	Enable the right (F) key
		 */
		public function setESDFControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""E"";
			downKey = ""D"";
			leftKey = ""S"";
			rightKey = ""F"";
		}
		
		/**
		 * Enables IJKL (right-sided or secondary player) controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (I) key
		 * @param	allowDown	Enable the down (K) key
		 * @param	allowLeft	Enable the left (J) key
		 * @param	allowRight	Enable the right (L) key
		 */
		public function setIJKLControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""I"";
			downKey = ""K"";
			leftKey = ""J"";
			rightKey = ""L"";
		}
		
		/**
		 * Enables HJKL (Rogue / Net-Hack) controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (K) key
		 * @param	allowDown	Enable the down (J) key
		 * @param	allowLeft	Enable the left (H) key
		 * @param	allowRight	Enable the right (L) key
		 */
		public function setHJKLControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""K"";
			downKey = ""J"";
			leftKey = ""H"";
			rightKey = ""L"";
		}
		
		/**
		 * Enables ZQSD (Azerty keyboard) controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (Z) key
		 * @param	allowDown	Enable the down (Q) key
		 * @param	allowLeft	Enable the left (S) key
		 * @param	allowRight	Enable the right (D) key
		 */
		public function setZQSDControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""Z"";
			downKey = ""S"";
			leftKey = ""Q"";
			rightKey = ""D"";
		}
		
		/**
		 * Enables Dvoark Simplified Controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (COMMA) key
		 * @param	allowDown	Enable the down (A) key
		 * @param	allowLeft	Enable the left (O) key
		 * @param	allowRight	Enable the right (E) key
		 */
		public function setDvorakSimplifiedControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""COMMA"";
			downKey = ""O"";
			leftKey = ""A"";
			rightKey = ""E"";
		}
		
		/**
		 * Enables Numpad (left-handed) Controls. Can be set on a per-key basis. Useful if you only want to allow a few keys.<br>
		 * For example in a Space Invaders game you'd only enable LEFT and RIGHT.
		 * 
		 * @param	allowUp		Enable the up (NUMPADEIGHT) key
		 * @param	allowDown	Enable the down (NUMPADTWO) key
		 * @param	allowLeft	Enable the left (NUMPADFOUR) key
		 * @param	allowRight	Enable the right (NUMPADSIX) key
		 */
		public function setNumpadControl(allowUp:Boolean = true, allowDown:Boolean = true, allowLeft:Boolean = true, allowRight:Boolean = true):void
		{
			up = allowUp;
			down = allowDown;
			left = allowLeft;
			right = allowRight;
			
			upKey = ""NUMPADEIGHT"";
			downKey = ""NUMPADTWO"";
			leftKey = ""NUMPADFOUR"";
			rightKey = ""NUMPADSIX"";
		}
		
		
	}

}",12191,False,2434.1391032426054,median
"/*
 * Copyright (C) 2003-2012 Igniterealtime Community Contributors
 *
 *     Daniel Henninger
 *     Derrick Grigg <dgrigg@rogers.com>
 *     Juga Paazmaya <olavic@gmail.com>
 *     Nick Velloff <nick.velloff@gmail.com>
 *     Sean Treadway <seant@oncotype.dk>
 *     Sean Voisen <sean@voisen.org>
 *     Mark Walters <mark@yourpalmark.com>
 *     Michael McCarthy <mikeycmccarthy@gmail.com>
 *
 *
 * 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.igniterealtime.xiff.conference
{
	import org.igniterealtime.xiff.collections.ArrayCollection;
	import org.igniterealtime.xiff.core.EscapedJID;
	import org.igniterealtime.xiff.core.IXMPPConnection;
	import org.igniterealtime.xiff.core.UnescapedJID;
	import org.igniterealtime.xiff.data.IExtension;
	import org.igniterealtime.xiff.data.IMessage;
	import org.igniterealtime.xiff.data.IQ;
	import org.igniterealtime.xiff.data.Message;
	import org.igniterealtime.xiff.data.Presence;
	import org.igniterealtime.xiff.data.forms.FormExtension;
	import org.igniterealtime.xiff.data.forms.enum.FormType;
	import org.igniterealtime.xiff.data.muc.*;
	import org.igniterealtime.xiff.events.DisconnectionEvent;
	import org.igniterealtime.xiff.events.MessageEvent;
	import org.igniterealtime.xiff.events.PresenceEvent;
	import org.igniterealtime.xiff.events.PropertyChangeEvent;
	import org.igniterealtime.xiff.events.RoomEvent;

	/**
	 * Dispatched when the active, affiliation, or role property changes.
	 *
	 * @eventType org.igniterealtime.xiff.events.PropertyChangeEvent.CHANGE
	 */
	[Event( name=""change"", type=""org.igniterealtime.xiff.events.PropertyChangeEvent"" )]
	/**
	 * Dispatched when an administration action failed.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.ADMIN_ERROR
	 * @see	org.igniterealtime.xiff.core.XMPPConnection.error
	 */
	[Event( name=""adminError"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when an affiliation change has completed.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.AFFILIATION_CHANGE_COMPLETE
	 */
	[Event( name=""affiliationChangeComplete"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when an affiliation list has been requested. The event object contains an
	 * array of <code>MUCItems</code> containing the JID and affiliation properties.
	 *
	 * <p>To grant or revoke permissions based on this list, only send the changes you wish to
	 * make, calling grant/revoke with the new affiliation and existing JID.</p>
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.AFFILIATIONS
	 */
	[Event( name=""affiliations"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched if the user attempted to join the room but was not allowed to do so because
	 * they are banned (i.e., has an affiliation of ""outcast"").
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.BANNED_ERROR
	 */
	[Event( name=""bannedError"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when a room configuration form is required.	This can occur during the
	 * creation of a room, or if a room configuration is requested.	The <code>RoomEvent</code>
	 * instance will contain an attribute <code>data</code> that is an instance of an object
	 * with the following attributes:
	 *
	 * <p><code>instructions</code>: Instructions for the use of form<br />
	 * <code>title</code>: Title of the configuration form<br />
	 * <code>label</code>: A friendly name for the field<br />
	 * <code>name</code>: A computer readable identifier for the field used to identify
	 * this field in the result passed to <code>configure()</code><br />
	 * <code>type</code>: The type of the field to be displayed. Type will be a constant
	 * from the <code>FormField</code> class.</p>
	 *
	 * @see	org.igniterealtime.xiff.data.forms.FormExtension
	 * @see	org.igniterealtime.xiff.data.forms.FormField
	 * @see	#configure
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.CONFIGURE_ROOM
	 */
	[Event( name=""configureRoom"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when a room configuration form is complete.
	 *
	 * @see #configure
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.CONFIGURE_ROOM_COMPLETE
	 */
	[Event(name=""configureRoomComplete"", type=""org.igniterealtime.xiff.events.RoomEvent"")]
	/**
	 * Dispatched when an invite to this room has been declined by the invitee. The <code>RoomEvent</code>
	 * <code>data</code> property that has the following attributes:
	 *
	 * <p><code>from</code>: The JID of the user initiating the invite<br />
	 * <code>reason</code>: A string containing the reason to join the room<br />
	 * <code>data</code>: The original message containing the decline</p>
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.DECLINED
	 */
	[Event( name=""declined"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched whenever a new message intented for all room occupants is received. The
	 * <code>RoomEvent</code> class will contain an attribute <code>data</code> with the
	 * group message as an instance of the <code>Message</code> class.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.GROUP_MESSAGE
	 */
	[Event( name=""groupMessage"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched if a user attempts to enter a room while it is ""locked"" (i.e., before the room
	 * creator provides an initial configuration and therefore before the room officially exists).
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.LOCKED_ERROR
	 */
	[Event( name=""lockedError"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched if the room has reached its maximum number of occupants.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.MAX_USERS_ERROR
	 */
	[Event( name=""maxUsersError"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when the user's preferred nickname already exists in the room.	The
	 * <code>RoomEvent</code> will contain an attribute <code>nickname</code> with the nickname
	 * already existing in the room.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.NICK_CONFLICT
	 */
	[Event( name=""nickConflict"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when the room requires a password and the user did not supply one (or
	 * the password provided is incorrect).
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.PASSWORD_ERROR
	 */
	[Event( name=""passwordError"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched whenever a new private message is received. The <code>RoomEvent</code> class
	 * contains an attribute <code>data</code> with the private message as an instance of the
	 * <code>Message</code> class.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.PRIVATE_MESSAGE
	 */
	[Event( name=""privateMessage"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when the room is members-only and the user is not on the member list.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.REGISTRATION_REQ_ERROR
	 */
	[Event( name=""registrationReqError"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when the room is removed.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.ROOM_DESTROYED
	 */
	[Event( name=""roomDestroyed"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when you have entered the room and messages that are sent
	 * will be displayed to other users. The room's role and affiliation will
	 * be visible from this point forward.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.ROOM_JOIN
	 */
	[Event( name=""roomJoin"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when the server acknoledges that you have the left the room.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.ROOM_LEAVE
	 */
	[Event( name=""roomLeave"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when the room subject changes.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.SUBJECT_CHANGE
	 */
	[Event( name=""subjectChange"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when a user is banned from the room.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.USER_BANNED
	 */
	[Event( name=""userBanned"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched whenever an occpant leaves the room. The <code>RoomEvent</code> instance will
	 * contain an attribute <code>nickname</code> with the nickname of the occupant who left.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.USER_DEPARTURE
	 */
	[Event( name=""userDeparture"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched whenever an occupant joins the room. The <code>RoomEvent</code> instance will
	 * contain an attribute <code>nickname</code> with the nickname of the occupant who joined.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.USER_JOIN
	 */
	[Event( name=""userJoin"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when a user is kicked from the room.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.USER_KICKED
	 */
	[Event( name=""userKicked"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]
	/**
	 * Dispatched when a user's presence changes.
	 *
	 * @eventType org.igniterealtime.xiff.events.RoomEvent.USER_PRESENCE_CHANGE
	 */
	[Event( name=""userPresenceChange"", type=""org.igniterealtime.xiff.events.RoomEvent"" )]

	/**
	 * Manages incoming and outgoing data from a conference room as part of multi-user conferencing (XEP-0045).
	 * You will need an instance of this class for each room that the user joins.
	 *
	 * @see http://xmpp.org/extensions/xep-0045.html
	 */
	public class Room extends ArrayCollection implements IRoom
	{
		public static const AFFILIATION_ADMIN:String = MUC.AFFILIATION_ADMIN;
		public static const AFFILIATION_MEMBER:String = MUC.AFFILIATION_MEMBER;
		public static const AFFILIATION_NONE:String = MUC.AFFILIATION_NONE;
		public static const AFFILIATION_OUTCAST:String = MUC.AFFILIATION_OUTCAST;
		public static const AFFILIATION_OWNER:String = MUC.AFFILIATION_OWNER;
		public static const ROLE_MODERATOR:String = MUC.ROLE_MODERATOR;
		public static const ROLE_NONE:String = MUC.ROLE_NONE;
		public static const ROLE_PARTICIPANT:String = MUC.ROLE_PARTICIPANT;
		public static const ROLE_VISITOR:String = MUC.ROLE_VISITOR;


		private var _active:Boolean;

		private var _affiliation:String;

		private var _anonymous:Boolean = true;

		private var _connection:IXMPPConnection;

		private var _nickname:String;

		private var _password:String;

		private var _role:String;

		private var _roomJID:UnescapedJID;

		private var _subject:String;

		private var _isReserved:Boolean;

		// Used to store nicknames in pending status, awaiting change approval from server
		private var _pendingNickname:String;

		private var _affiliationExtension:MUCBaseExtension; // TODO: How about using Interface here?
		private var _affiliationArgs:Array = [];

		/**
		 *
		 * @param	aConnection  A XMPPConnection instance that is providing the primary server connection
		 */
		public function Room( aConnection:IXMPPConnection = null )
		{
			setActive(false);
			if ( aConnection != null )
			{
				connection = aConnection;
			}
			_affiliationExtension = new MUCAdminExtension();
		}

		/**
		 * Allow a previously banned JIDs to enter this room.	This is the same as:
		 * <code>Room.grant(AFFILIATION_NONE, jid)</code>
		 *
		 * <p>If the process could not be completed, the room will dispatch the event
		 * <code>RoomEvent.ADMIN_ERROR</code></p>
		 *
		 * @param	jids An array of unescaped JIDs to allow
		 * @see	#grant
		 * @see	#revoke
		 */
		public function allow( jids:Array ):void
		{
			grant( Room.AFFILIATION_NONE, jids );
		}

		/**
		 * Bans an array of JIDs from entering the room.
		 *
		 * <p>If the process could not be completed, the room will dispatch the event
		 * <code>RoomEvent.ADMIN_ERROR</code>.</p>
		 *
		 * @param	jids An arry of unescaped JIDs to ban
		 */
		public function ban( jids:Array ):void
		{
			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET, null, ban_response, ban_error );
			var adminExt:MUCAdminExtension = new MUCAdminExtension();

			for each ( var banJID:UnescapedJID in jids )
			{
				adminExt.addItem( Room.AFFILIATION_OUTCAST, null, null, banJID.escaped, null, null );
			}

			iq.addExtension( adminExt );
			_connection.send( iq );
		}

		/**
		 * Cancels the configuration process.	The room may still be locked if
		 * you cancel the configuration process when attempting to join a
		 * reserved room.
		 *
		 * <p>You must have joined the room and have the owner affiliation to
		 * configure the room.</p>
		 *
		 * @see	#configureRoom
		 * @see	#configure
		 * @see	#join
		 */
		public function cancelConfiguration():void
		{
			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET );
			var ownerExt:MUCOwnerExtension = new MUCOwnerExtension();
			var form:FormExtension = new FormExtension();

			form.type = FormType.CANCEL;

			ownerExt.addExtension( form );
			iq.addExtension( ownerExt );
			_connection.send( iq );
		}

		/**
		 * Changes the subject in the conference room. You must have already joined the
		 * room before you can change the subject.
		 *
		 * @param	newSubject The new subject
		 */
		public function changeSubject( newSubject:String ):void
		{
			if ( active )
			{
				var message:Message = new Message( roomJID.escaped, null, null,
													   null, Message.TYPE_GROUPCHAT,
													   newSubject );
				_connection.send( message );
			}
		}

		/**
		 * Sends a configuration form to the room.
		 *
		 * You must be joined and have owner affiliation to configure the room
		 *
		 * @param	fieldmap FormExtension, or a hash that is an object with keys being the room configuration
		 * form variables and the values being arrays. For single value fields, use a single
		 * element array.
		 * @see	#configureRoom
		 * @see http://xmpp.org/extensions/xep-0045.html#registrar-formtype-owner
		 */
		public function configure( fieldmap:Object ):void
		{
			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET, null, configure_response, configure_error );
			var ownerExt:MUCOwnerExtension = new MUCOwnerExtension();
			var form:FormExtension;

			if ( fieldmap is FormExtension )
			{
				form = FormExtension( fieldmap );
			}
			else
			{
				form = new FormExtension();
				fieldmap[ ""FORM_TYPE"" ] = [ ""http://jabber.org/protocol/muc#roomconfig"" ];
				form.setFieldMap( fieldmap );
			}
			form.type = FormType.SUBMIT;
			ownerExt.addExtension( form );

			iq.addExtension( ownerExt );

			_connection.send( iq );
		}

		/**
		 * Actively decline an invitation.	You can optionally ignore invitations
		 * but if you choose to decline an invitation, you call this method on
		 * a room instance that represents the room the invite originated from.
		 *
		 * <p>You do not need to have joined this room to decline an invitation</p>
		 *
		 * <p>Note: mu-conference-0.6 does not allow users to send decline
		 * messages without joining first.	If using this version of conferencing
		 * software, it is best to ignore invites.</p>
		 *
		 * @param	jid	An unescaped JID of the user to invite.
		 * @param	reason A string describing why the invitiation was declined
		 */
		public function decline( jid:UnescapedJID, reason:String ):void
		{
			var message:Message = new Message( roomJID.escaped );
			var userExt:MUCUserExtension = new MUCUserExtension();

			userExt.decline( jid.escaped, undefined, reason );

			message.addExtension( userExt );
			_connection.send( message );
		}

		/**
		 * Destroys a reserved room.	If the room has been configured to be persistent,
		 * then it is optional that the server will permanently remove the room.
		 *
		 * @param	reason A short description of why the room is being destroyed
		 * @param	alternateJID A JID for current members to use as an alternate room to join
		 * after the room has been destroyed. Like a postal forwarding address.
		 */
		public function destroy( reason:String, alternateJID:UnescapedJID = null, callback:Function = null ):void
		{
			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET );
			var ownerExt:MUCOwnerExtension = new MUCOwnerExtension();
			var jid:EscapedJID;
			if (alternateJID != null)
			{
				jid = alternateJID.escaped;
			}

			iq.callback = callback;
			ownerExt.destroy( reason, jid );

			iq.addExtension( ownerExt );
			_connection.send( iq );
		}

		/**
		 * Gets an instance of the <code>Message</code> class that has been pre-configured to be
		 * sent from this room. Use this method to get a <code>Message</code> in order to add extensions
		 * to outgoing room messages.
		 *
		 * @param	body The message body
		 * @param	htmlBody The message body with HTML formatting
		 * @return A <code>Message</code> class instance
		 */
		public function getMessage( body:String = null, htmlBody:String = null ):IMessage
		{
			var message:Message = new Message( roomJID.escaped, null, body, htmlBody,
												   Message.TYPE_GROUPCHAT );
			return message;
		}

		/**
		 * Gets the <code>RoomOccupant</code> whose nickname matches the name passed in.
		 *
		 * @param	name
		 * @return
		 */
		public function getOccupantNamed( name:String ):IRoomOccupant
		{
			for each ( var occ:RoomOccupant in this )
			{
				if ( occ.nickname == name )
				{
					return occ;
				}
			}
			return null;
		}

		/**
		 * Grants permissions on a room to one or more JIDs by setting the
		 * affiliation of a user based on their JID.
		 *
		 * <p>If the JID currently has an existing affiliation, then the existing
		 * affiliation will be replaced with the one passed. If the process could not be
		 * completed, the room will dispatch the event <code>RoomEvent.ADMIN_ERROR</code>.</p>
		 *
		 * <p>XMPP spec states that the #admin schema should be used for affiliation changes.
		 * Unfortunately to this date, Openfire does not match spec and requires the #owner schema.
		 * Because of this, if granting privileges fails on the first attempt using the #admin schema,
		 * we try again using the #owner schema.</p>
		 *
		 * @param	affiliation Use one of the
		 * following affiliations: <code>Room.AFFILIATION_MEMBER</code>,
		 * <code>Room.AFFILIATION_ADMIN</code>,
		 * <code>Room.AFFILIATION_OWNER</code>
		 * @param	jids An array of UnescapedJIDs to grant these permissions to
		 * @see	#revoke
		 * @see	#allow
		 * @see http://xmpp.org/extensions/xep-0045.html#schemas-admin
		 */
		public function grant( affiliation:String, jids:Array ):void
		{
			_affiliationArgs = arguments;

			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET, null, grant_response, grant_error );

			for each ( var jid:UnescapedJID in jids )
			{
				_affiliationExtension.addItem( affiliation, null, null, jid.escaped, null, null );
			}

			iq.addExtension( _affiliationExtension as IExtension );
			_connection.send( iq );
		}

		/**
		 * Invites a user that is not currently a member of this room to this room.
		 *
		 * <p>You must have joined the room and have appropriate permissions to invite
		 * other memebers, because the server will format and send the invite message to
		 * as if it came from the room rather that you sending the invite directly from you.</p>
		 *
		 * <p>To listen to invite events, add an event listener on your XMPPConnection to the
		 * <code>InviteEvent.INVITED</code> event.</p>
		 *
		 * @param	jid	An unescaped JID of the user to invite.
		 * @param	reason A string describing why you would like to invite the user.
		 */
		public function invite( jid:UnescapedJID, reason:String ):void
		{
			var message:Message = new Message( roomJID.escaped );
			var userExt:MUCUserExtension = new MUCUserExtension();

			userExt.invite( jid.escaped, undefined, reason );

			message.addExtension( userExt );
			_connection.send( message );
		}

		/**
		 * Determines if the <code>sender</code> parameter is the same
		 * as the room's JID.
		 *
		 * @param	the room JID to test
		 * @return true if the passed JID matches the getRoomJID
		 */
		public function isThisRoom( sender:UnescapedJID ):Boolean
		{
			return _roomJID ? sender.bareJID.toLowerCase() == _roomJID.bareJID.toLowerCase() : false;
		}

		/**
		 * Determines if the <code>sender</code> param is the
		 * same as the user's JID.
		 *
		 * @param	sender	the room JID to test
		 * @return true if the passed JID matches the userJID
		 */
		public function isThisUser( sender:UnescapedJID ):Boolean
		{
			var value:Boolean = false;
			if (userJID != null)
			{
				value = sender.toString().toLowerCase() == userJID.toString().toLowerCase();
			}
			return value;
		}

		/**
		 * Joins a conference room based on the parameters specified by the room
		 * properties.	This call will create an instant room based on a default
		 * server configuration if the room doesn't exist.
		 *
		 * <p>To create and begin the configuration process of a reserved room, pass
		 * <code>true</code> to this method to begin the configuration process.	When
		 * The configuration is complete, the room will be unlocked for others to join.
		 * Listen for the <code>RoomEvent.CONFIGURE_ROOM</code> event to handle and
		 * either return or cancel the configuration of the room.</p>
		 *
		 * @param	createReserved Set to true if you wish to create and configure a reserved room
		 * @param	joinPresenceExtensions An array of additional extensions to send with the initial presence to the room.
		 * @return A boolean indicating whether the join attempt was successfully sent.
		 */
		public function join( createReserved:Boolean = false, joinPresenceExtensions:Array = null ):Boolean
		{
			var muc:MUCExtension = new MUCExtension();

			if ( password != null )
			{
				muc.password = password;
			}

			return joinWithExplicitMUCExtension(createReserved, muc, joinPresenceExtensions);
		}

		/**
		 * Joins a conference room based on the parameters specified by the room
		 * properties.	This call will create an instant room based on a default
		 * server configuration if the room doesn't exist.
		 *
		 * <p>To create and begin the configuration process of a reserved room, pass
		 * <code>true</code> to this method to begin the configuration process.	When
		 * The configuration is complete, the room will be unlocked for others to join.
		 * Listen for the <code>RoomEvent.CONFIGURE_ROOM</code> event to handle and
		 * either return or cancel the configuration of the room.</p>
		 *
		 * <p>This function adds an additional parameter to allow the caller to completely customize the MUC extension that
		 * gets sent to the room.  For example, you can add a history element that specifies how much discussion
		 * history you want sent when you join the room (http://xmpp.org/extensions/xep-0045.html#enter-managehistory):
		 * <code>
		 * var muc:MUCExtension = new MUCExtension();
		 * muc.history = true;
		 * muc.maxchars = 0;
		 * _room.joinWithExplicitMUCExtension(false, mucExt);
		 * </code>
		 * </p>
		 *
		 * @param	createReserved Set to true if you wish to create and configure a reserved room
		 * @param	mucExtension The customized MUC extension to send with initial presence to the room.
		 * @param	joinPresenceExtensions An array of additional extensions to send with the initial presence to the room.
		 * @return A boolean indicating whether the join attempt was successfully sent.
		 */
		public function joinWithExplicitMUCExtension( createReserved:Boolean, mucExtension:IMUCExtension, joinPresenceExtensions:Array = null ):Boolean
		{
			if ( !_connection.active || active )
			{
				return false;
			}

			_isReserved = createReserved;

			var joinPresence:Presence = new Presence( userJID.escaped );
			joinPresence.addExtension( mucExtension );

			if ( joinPresenceExtensions != null )
			{
				for each ( var joinExt:IExtension in joinPresenceExtensions )
				{
					joinPresence.addExtension( joinExt );
				}
			}

			_connection.send( joinPresence );
			return true;
		}

		/**
		 * Kicks an occupant out of the room, assuming that the user has necessary
		 * permissions in order to do so. If the user does not, the server will return an error.
		 *
		 * @param	occupantNick The nickname of the room occupant to kick
		 * @param	reason The reason for the kick
		 */
		public function kickOccupant( occupantNick:String, reason:String ):void
		{
			if ( active )
			{
				var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET, IQ.generateID( ""kick_occupant_"" ) );
				var adminExt:MUCAdminExtension = new MUCAdminExtension( iq.xml );
				adminExt.addItem( null, MUC.ROLE_NONE, occupantNick, null, null, reason );
				iq.addExtension( adminExt );
				_connection.send( iq );
			}
		}

		/**
		 * Leaves the current conference room, assuming that the user has joined one.
		 * If the user is not currently in a room, this method does nothing.
		 */
		public function leave():void
		{
			if ( active )
			{
				var leavePresence:Presence = new Presence( userJID.escaped, null, Presence.TYPE_UNAVAILABLE );
				_connection.send( leavePresence );

				// Clear out the roster items
				removeAll();
				_connection.removeEventListener( MessageEvent.MESSAGE, handleEvent );
				_connection.removeEventListener( DisconnectionEvent.DISCONNECT, handleEvent );
			}
		}

		/**
		 * Requests an affiliation list for a given affiliation with with room.
		 * This will either dispatch the event <code>RoomEvent.AFFILIATIONS</code> or
		 * <code>RoomEvent.ADMIN_ERROR</code> depending on the result of the request.
		 *
		 * @param	affiliation Use one of the following affiliations: <code>Room.AFFILIATION_NONE</code>,
		 * <code>Room.AFFILIATION_OUTCAST</code>,
		 * <code>Room.AFFILIATION_MEMBER</code>,
		 * <code>Room.AFFILIATION_ADMIN</code>,
		 * <code>Room.AFFILIATION_OWNER</code>
		 * @see	#revoke
		 * @see	#grant
		 * @see	#affiliations
		 */
		public function requestAffiliations( affiliation:String ):void
		{
			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_GET, null, requestAffiliations_response, requestAffiliations_error );
			var adminExt:MUCAdminExtension = new MUCAdminExtension();

			adminExt.addItem( affiliation );

			iq.addExtension( adminExt );
			_connection.send( iq );
		}

		/**
		 * Requests a configuration form from the room.	Listen to <code>configureRoom</code>
		 * event to fill out the form then call either <code>configure</code> or
		 * <code>cancelConfiguration</code> to complete the configuration process
		 *
		 * You must be joined to the room and have the owner affiliation to request
		 * a configuration form
		 *
		 * @see	#configureRoom
		 * @see	#configure
		 * @see	#cancelConfiguration
		 */
		public function requestConfiguration():void
		{
			var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_GET, null, requestConfiguration_response, requestConfiguration_error );
			var ownerExt:MUCOwnerExtension = new MUCOwnerExtension();

			iq.addExtension( ownerExt );

			_connection.send( iq );
		}

		/**
		 * Revokes all affiliations from the JIDs. This is the same as:
		 * <code>grant( Room.AFFILIATION_NONE, jids )</code>
		 *
		 * <p>If the process could not be completed, the room will dispatch the event
		 * <code>RoomEvent.ADMIN_ERROR</code>. Note: if the JID is banned from this room,
		 * then this will also revoke the banned status.</p>
		 *
		 * @param	jids An array of UnescapedJIDs to revoke affiliations from
		 * @see	#grant
		 * @see	#allow
		 */
		public function revoke( jids:Array ):void
		{
			grant( Room.AFFILIATION_NONE, jids );
		}

		/**
		 * Sends a message to the conference room.
		 *
		 * @param	body The message body
		 * @param	htmlBody The message body with HTML formatting
		 */
		public function sendMessage( body:String = null, htmlBody:String = null ):void
		{
			if ( active )
			{
				var message:Message = new Message( roomJID.escaped, null, body, htmlBody, Message.TYPE_GROUPCHAT );
				_connection.send( message );
			}
		}

		/**
		 * Sends a message to the conference room with an extension attached.
		 * Use this method in conjunction with the <code>getMessage</code> method.
		 *
		 * @param	message The message to send
		 */
		public function sendMessageWithExtension( message:IMessage ):void
		{
			if ( active )
			{
				_connection.send( message );
			}
		}

		/**
		 * Sends a private message to a specific participant in the conference room.
		 *
		 * @param	recipientNickname The conference room nickname of the recipient who should
		 * receive the private message
		 * @param	body The message body
		 * @param	htmlBody The message body with HTML formatting
		 */
		public function sendPrivateMessage( recipientNickname:String, body:String = null, htmlBody:String = null ):void
		{
			if ( active )
			{
				var message:Message = new Message( new EscapedJID( roomJID + ""/"" + recipientNickname ), null, body, htmlBody, Message.TYPE_CHAT );
				_connection.send( message );
			}
		}

		/**
		 * In a moderated room, sets voice status to a particular occupant, assuming the user
		 * has the necessary permissions to do so.
		 *
		 * @param	occupantNick The nickname of the occupant to give voice
		 * @param	voice Whether to add voice (true) or remove voice (false). Having voice means
		 * that the user is actually able to talk. Without voice the user is effectively muted.
		 */
		public function setOccupantVoice( occupantNick:String, voice:Boolean ):void
		{
			if ( active )
			{
				var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET, IQ.generateID( ""voice_"" ) );
				var adminExt:MUCAdminExtension = new MUCAdminExtension( iq.xml );
				adminExt.addItem( null, voice ? MUC.ROLE_PARTICIPANT : MUC.ROLE_VISITOR, occupantNick );
				iq.addExtension( adminExt );
				_connection.send( iq );
			}
		}

		/**
		 * @private
		 */
		override public function toString():String
		{
			return '[object Room]';
		}

		/**
		 * @private
		 *
		 * The default error handler for admin IQ messages.
		 * Dispatches the adminError event.
		 */
		private function admin_error( iq:IQ ):void
		{
			var event:RoomEvent = new RoomEvent( RoomEvent.ADMIN_ERROR );
			event.errorCondition = iq.errorCondition;
			event.errorMessage = iq.errorMessage;
			event.errorType = iq.errorType;
			event.errorCode = iq.errorCode;
			dispatchEvent( event );
		}

		/**
		 * @private
		 *
		 * The default response handler for admin IQ messages.
		 */
		private function admin_response( iq:IQ ):void
		{
		}

		/**
		 * @private
		 */
		private function ban_error( iq:IQ ):void
		{
			admin_error( iq );
		}

		/**
		 * @private
		 */
		private function ban_response( iq:IQ ):void
		{
		}

		/**
		 * @private
		 */
		private function configure_error( iq:IQ ):void
		{
			admin_error( iq );
		}

		/**
		 * @private
		 */
		private function configure_response( iq:IQ ):void
		{
			var event:RoomEvent = new RoomEvent( RoomEvent.CONFIGURE_ROOM_COMPLETE );
			dispatchEvent( event );
		}

		/**
		 * Helper to dispatch a property change event.
		 * @param	name
		 * @param	newValue
		 * @param	oldValue
		 */
		private function dispatchChangeEvent( name:String, newValue:*, oldValue:* ):void
		{
			var event:PropertyChangeEvent = new PropertyChangeEvent( PropertyChangeEvent.CHANGE );
			event.name = name;
			event.newValue = newValue;
			event.oldValue = oldValue;
			dispatchEvent( event );
		}

		/**
		 * @private
		 */
		private function grant_error( iq:IQ ):void
		{
			if ( _affiliationExtension is MUCAdminExtension && _affiliationArgs.length > 0 )
			{
				_affiliationExtension = new MUCOwnerExtension();
				grant.apply( null, _affiliationArgs );
			}
			else
			{
				_affiliationArgs = [];
				admin_error( iq );
			}
		}

		/**
		 * @private
		 */
		private function grant_response( iq:IQ ):void
		{
			_affiliationArgs = [];

			var event:RoomEvent = new RoomEvent( RoomEvent.AFFILIATION_CHANGE_COMPLETE );
			dispatchEvent( event );
		}

		/**
		 * @private
		 *
		 * @param	eventObj
		 */
		private function handleEvent( eventObj:Object ):void
		{
			var userExt:MUCUserExtension;

			switch ( eventObj.type )
			{
				case ""message"":
					var message:Message = eventObj.data;
					var userExts:Array = message.getAllExtensionsByNS( MUCUserExtension.NS );
					var roomEvent:RoomEvent;

					// Check to see that the message is from this room
					if ( isThisRoom( message.from.unescaped ))
					{
						if ( message.type == Message.TYPE_GROUPCHAT )
						{
							// Check for a subject change
							if ( message.subject != null )
							{
								_subject = message.subject;
								roomEvent = new RoomEvent( RoomEvent.SUBJECT_CHANGE );
								roomEvent.subject = message.subject;
								dispatchEvent( roomEvent );
							}
							else
							{
								//silently ignore ""room is not anonymous"" message, identified by status code 100
								//Clients should display that information in their UI based on the appropriate room property
								if ( !userExts || userExts.length == 0 || !( userExts[ 0 ].hasStatusCode( 100 )))
								{
									roomEvent = new RoomEvent( RoomEvent.GROUP_MESSAGE );
									roomEvent.nickname = message.from.resource;
									roomEvent.data = message;
									dispatchEvent( roomEvent );
								}
							}
						}
						else if ( message.type == Message.TYPE_NORMAL )
						{
							var form:Array = message.getAllExtensionsByNS( FormExtension.NS )[ 0 ];
							if ( form )
							{
								roomEvent = new RoomEvent( RoomEvent.CONFIGURE_ROOM );
								roomEvent.data = form;
								dispatchEvent( roomEvent );
							}
						}
						else if ( message.type == Message.TYPE_CHAT )
						{
							roomEvent = new RoomEvent( RoomEvent.PRIVATE_MESSAGE );
							roomEvent.nickname = message.from.resource;
							roomEvent.data = message;
							dispatchEvent( roomEvent );
						}
					}
					else if ( isThisUser( message.to.unescaped ) && message.type == Message.TYPE_CHAT )
					{
						// It could be a private message via the conference
						roomEvent = new RoomEvent( RoomEvent.PRIVATE_MESSAGE );
						roomEvent.data = message;
						dispatchEvent( roomEvent );
					}
					else
					{
						// Could be a decline to a previous invite
						if ( userExts != null && userExts.length > 0 )
						{
							userExt = userExts[ 0 ];
							if ( userExt && userExt.type == MUCUserExtension.TYPE_DECLINE )
							{
								roomEvent = new RoomEvent( RoomEvent.DECLINED );
								roomEvent.from = userExt.reason;
								roomEvent.reason = userExt.reason;
								roomEvent.data = message;
								dispatchEvent( roomEvent );
							}
						}
					}
					break;

				case ""presence"":
					for each ( var presence:Presence in eventObj.data )
					{
						if ( presence.type == Presence.TYPE_ERROR )
						{
							switch ( presence.errorCode )
							{
								case 401:
									roomEvent = new RoomEvent( RoomEvent.PASSWORD_ERROR );
									break;

								case 403:
									roomEvent = new RoomEvent( RoomEvent.BANNED_ERROR );
									break;

								case 404:
									roomEvent = new RoomEvent( RoomEvent.LOCKED_ERROR );
									break;

								case 407:
									roomEvent = new RoomEvent( RoomEvent.REGISTRATION_REQ_ERROR );
									break;

								case 409:
									roomEvent = new RoomEvent( RoomEvent.NICK_CONFLICT );
									roomEvent.nickname = nickname;
									break;

								case 503:
									roomEvent = new RoomEvent( RoomEvent.MAX_USERS_ERROR );
									break;

								default:
									roomEvent = new RoomEvent( ""MUC Error of type: "" + presence.errorCode );
									break;
							}
							roomEvent.errorCode = presence.errorCode;
							roomEvent.errorMessage = presence.errorMessage;
							dispatchEvent( roomEvent );
						}
						else if ( isThisRoom( presence.from.unescaped ))
						{
							// If the presence has our pending nickname, nickname change went through
							if ( presence.from.resource == _pendingNickname )
							{
								_nickname = _pendingNickname;
								_pendingNickname = null;
							}

							userExt = presence.getAllExtensionsByNS( MUCUserExtension.NS )[ 0 ];
							for each ( var status:MUCStatus in userExt.statuses )
							{
								switch ( status.code )
								{
									case 100:
									case 172:
										_anonymous = false;
										break;

									case 174:
										_anonymous = true;
										break;

									case 201:
										unlockRoom( _isReserved );
										break;
								}
							}

							updateRoomRoster( presence );

							if ( presence.type == Presence.TYPE_UNAVAILABLE && active &&
								isThisUser( presence.from.unescaped ))
							{
								setActive(false);
								if ( userExt.type == MUCUserExtension.TYPE_DESTROY )
								{
									roomEvent = new RoomEvent( RoomEvent.ROOM_DESTROYED );
								}
								else
								{
									roomEvent = new RoomEvent( RoomEvent.ROOM_LEAVE );
								}
								dispatchEvent( roomEvent );
								_connection.removeEventListener( PresenceEvent.PRESENCE, handleEvent );
							}
						}
					}
					break;

				case ""disconnection"":
					// The server disconnected, so we are no longer active
					setActive(false);
					removeAll();
					roomEvent = new RoomEvent( RoomEvent.ROOM_LEAVE );
					dispatchEvent( roomEvent );
					break;
			}
		}

		/**
		 * @private
		 */
		private function requestAffiliations_error( iq:IQ ):void
		{
			admin_error( iq );
		}

		/**
		 * @private
		 */
		private function requestAffiliations_response( iq:IQ ):void
		{
			if ( iq.type == IQ.TYPE_RESULT )
			{
				var adminExt:MUCAdminExtension = iq.getAllExtensionsByNS( MUCAdminExtension.NS )[ 0 ];
				var event:RoomEvent = new RoomEvent( RoomEvent.AFFILIATIONS );
				event.data = adminExt.items;
				dispatchEvent( event );
			}
		}

		/**
		 * @private
		 */
		private function requestConfiguration_error( iq:IQ ):void
		{
			admin_error( iq );
		}

		/**
		 * @private
		 */
		private function requestConfiguration_response( iq:IQ ):void
		{
			var ownerExt:MUCOwnerExtension = iq.getAllExtensionsByNS( MUCOwnerExtension.NS )[ 0 ];
			var form:FormExtension = ownerExt.getAllExtensionsByNS( FormExtension.NS )[ 0 ];

			if ( form.type == FormType.FORM )
			{
				var event:RoomEvent = new RoomEvent( RoomEvent.CONFIGURE_ROOM );
				event.data = form;
				dispatchEvent( event );
			}
		}

		/**
		 * @private
		 *
		 * Room owner (creation/configuration/destruction) methods
		 * @see	http://xmpp.org/extensions/xep-0045.html#createroom
		 */
		private function unlockRoom( isReserved:Boolean ):void
		{
			if ( isReserved )
			{
				requestConfiguration();
			}
			else
			{
				// Send an empty configuration form to open the instant room

				// The IQ.result for this request will signify that the room is
				// unlocked.	Sometimes there are messages that are sent before
				// the request is returned.	It may be smart to either block those
				// messages, or provide 2 events ""beginConfiguration"" and ""endConfiguration""
				// so the application can decide to block configuration messages

				var iq:IQ = new IQ( roomJID.escaped, IQ.TYPE_SET );
				var ownerExt:MUCOwnerExtension = new MUCOwnerExtension();
				var form:FormExtension = new FormExtension();

				form.type = FormType.SUBMIT;

				ownerExt.addExtension( form );
				iq.addExtension( ownerExt );
				_connection.send( iq );
			}
		}

		/**
		 * @private
		 *
		 * If we receive a presence about ourselves, it means
		 * a) we've joined the room; tell everyone, then proceed as usual
		 * b) we're being told we left, which we handle in the caller
		 * @param	aPresence
		 */
		private function updateRoomRoster( aPresence:Presence ):void
		{
			var userNickname:String = aPresence.from.unescaped.resource;
			var userExts:Array = aPresence.getAllExtensionsByNS( MUCUserExtension.NS );
			var item:MUCItem = userExts[ 0 ].items[ 0 ];
			var roomEvent:RoomEvent;

			if ( isThisUser( aPresence.from.unescaped ))
			{
				if ( _affiliation != item.affiliation )
				{
					dispatchChangeEvent( ""affiliation"",item.affiliation,  _affiliation );
				}
				_affiliation = item.affiliation;

				if ( _role != item.role )
				{
					dispatchChangeEvent( ""role"", item.role, _role );
				}
				_role = item.role;

				if ( !active && aPresence.type != Presence.TYPE_UNAVAILABLE )
				{
					setActive(true);
					roomEvent = new RoomEvent( RoomEvent.ROOM_JOIN );
					dispatchEvent( roomEvent );
				}
			}

			var occupant:IRoomOccupant = getOccupantNamed( userNickname );

			//if we already know about this occupant, we're either being told about them leaving, or about a presence update
			if ( occupant )
			{
				if ( aPresence.type == Presence.TYPE_UNAVAILABLE )
				{
					removeItemAt( getItemIndex( occupant ));

					var userExt:MUCUserExtension = aPresence.getAllExtensionsByNS( MUCUserExtension.NS )[ 0 ];
					for each ( var status:MUCStatus in userExt.statuses )
					{
						switch ( status.code )
						{
							// If the user left as a result of a ban or kick, we dispatch a USER_BANNED/USER_KICKED event instead of a USER_DEPARTURE event
							case 301:
								roomEvent = new RoomEvent( RoomEvent.USER_BANNED );
								roomEvent.nickname = userNickname;
								roomEvent.data = aPresence;
								dispatchEvent( roomEvent );
								return;

							case 307:
								roomEvent = new RoomEvent( RoomEvent.USER_KICKED );
								roomEvent.nickname = userNickname;
								roomEvent.data = aPresence;
								dispatchEvent( roomEvent );
								return;
						}
					}

					// Notify listeners that a user has left the room
					roomEvent = new RoomEvent( RoomEvent.USER_DEPARTURE );
					roomEvent.nickname = userNickname;
					roomEvent.data = aPresence;
					dispatchEvent( roomEvent );
				}
				else
				{
					occupant.affiliation = item.affiliation;
					occupant.role = item.role;
					occupant.show = aPresence.show;

					// Notify listeners that a user's presence has been updated
					roomEvent = new RoomEvent( RoomEvent.USER_PRESENCE_CHANGE );
					roomEvent.nickname = userNickname;
					roomEvent.data = aPresence;
					dispatchEvent( roomEvent );
				}
			}
			else if ( aPresence.type != Presence.TYPE_UNAVAILABLE )
			{
				// We didn't know about this occupant yet, so we add them, then let everyone know that we did.
				addItem( new RoomOccupant( userNickname, aPresence.show, item.affiliation,
										   item.role, item.jid ? item.jid.unescaped :
										   null, this ));

				roomEvent = new RoomEvent( RoomEvent.USER_JOIN );
				roomEvent.nickname = userNickname;
				roomEvent.data = aPresence;
				dispatchEvent( roomEvent );
			}
		}

		/**
		 * Gets the user's affiliation for this room.
		 * Possible affiliations are ""owner"", ""admin"", ""member"", and ""outcast"".
		 * It is also possible to have no defined affiliation.
		 */
		public function get affiliation():String
		{
			return _affiliation;
		}

		/**
		 * Whether the room shows full JIDs or not.
		 */
		public function get anonymous():Boolean
		{
			return _anonymous;
		}

		/**
		 * A reference to the XMPPConnection being used for incoming/outgoing XMPP data.
		 *
		 * @see	org.igniterealtime.xiff.core.XMPPConnection
		 */
		public function get connection():IXMPPConnection
		{
			return _connection;
		}
		public function set connection( value:IXMPPConnection ):void
		{
			if ( _connection != null )
			{
				_connection.removeEventListener( MessageEvent.MESSAGE, handleEvent );
				_connection.removeEventListener( PresenceEvent.PRESENCE, handleEvent );
				_connection.removeEventListener( DisconnectionEvent.DISCONNECT, handleEvent );
			}

			_connection = value;

			_connection.addEventListener( MessageEvent.MESSAGE, handleEvent, false, 0, true );
			_connection.addEventListener( PresenceEvent.PRESENCE, handleEvent, false, 0, true );
			_connection.addEventListener( DisconnectionEvent.DISCONNECT, handleEvent, false, 0, true );

			_connection.enableExtensions(
				FormExtension,
				MUCExtension,
				MUCUserExtension,
				MUCOwnerExtension,
				MUCAdminExtension
			);
		}

		/**
		 * The conference server to use for this room. Usually, this is a subdomain of
		 * the primary XMPP server, like conference.myserver.com.
		 */
		public function get conferenceServer():String
		{
			return _roomJID ? _roomJID.domain : null;
		}
		public function set conferenceServer( value:String ):void
		{
			roomJID = new UnescapedJID( roomName + ""@"" + value );
		}

		/**
		 * Determines whether the connection to the room is active - that is, the user
		 * is connected and has joined the room.
		 */
		public function get active():Boolean
		{
			return _active;
		}
		
		/**
		 * Needs to be available only within this class
		 *
		 * @param	state
		 */
		private function setActive( state:Boolean ):void
		{
			if ( _active != state )
			{
				dispatchChangeEvent( ""active"", state, _active );
			}
			_active = state;
		}

		/**
		 * The nickname to use when joining.
		 */
		public function get nickname():String
		{
			return _nickname == null ? _connection.username : _nickname;
		}
		public function set nickname( value:String ):void
		{
			if ( active )
			{
				_pendingNickname = value;
				var presence:Presence = new Presence( new EscapedJID( userJID + ""/"" + value ) );
				_connection.send( presence );
			}
			else
			{
				_nickname = value;
			}
		}

		/**
		 * The password.
		 */
		public function get password():String
		{
			return _password;
		}
		public function set password( value:String ):void
		{
			_password = value;
		}

		/**
		 * Gets the user's role in the conference room.
		 *
		 * <p>Possible roles are ""visitor"", ""participant"", ""moderator"" or no defined role.</p>
		 * <ul>
		 * <li>ROLE_MODERATOR</li>
		 * <li>ROLE_NONE</li>
		 * <li>ROLE_PARTICIPANT</li>
		 * <li>ROLE_VISITOR</li>
		 * </ul>
		 */
		public function get role():String
		{
			return _role;
		}

		/**
		 * The unescaped JID of the room. <code>room&#64;conference.server</code>
		 * Set this after initiating a new Room.
		 */
		public function get roomJID():UnescapedJID
		{
			return _roomJID;
		}
		public function set roomJID( jid:UnescapedJID ):void
		{
			_roomJID = jid;
		}

		/**
		 * The room name that should be used when joining.
		 */
		public function get roomName():String
		{
			return _roomJID ? _roomJID.localpart : null;
		}
		public function set roomName( value:String ):void
		{
			roomJID = new UnescapedJID( value + ""@"" + conferenceServer );
		}

		/**
		 * The subject.
		 */
		public function get subject():String
		{
			return _subject;
		}

		/**
		 * Get the JID of the conference room user.
		 */
		public function get userJID():UnescapedJID
		{
			return _roomJID ? new UnescapedJID( _roomJID.bareJID + ""/"" + nickname ) : null;
		}
	}
}
",12520,False,2363.3316038039666,median
"package com.ankamagames.berilia.components
{
   import com.ankamagames.berilia.Berilia;
   import com.ankamagames.berilia.FinalizableUIComponent;
   import com.ankamagames.berilia.UIComponent;
   import com.ankamagames.berilia.components.messages.TextClickMessage;
   import com.ankamagames.berilia.events.LinkInteractionEvent;
   import com.ankamagames.berilia.factories.HyperlinkFactory;
   import com.ankamagames.berilia.managers.CssManager;
   import com.ankamagames.berilia.managers.TooltipManager;
   import com.ankamagames.berilia.managers.UiModuleManager;
   import com.ankamagames.berilia.types.LocationEnum;
   import com.ankamagames.berilia.types.data.ExtendedStyleSheet;
   import com.ankamagames.berilia.types.data.TextTooltipInfo;
   import com.ankamagames.berilia.types.graphic.ButtonContainer;
   import com.ankamagames.berilia.types.graphic.GraphicContainer;
   import com.ankamagames.berilia.types.graphic.UiRootContainer;
   import com.ankamagames.jerakine.data.XmlConfig;
   import com.ankamagames.jerakine.interfaces.IRectangle;
   import com.ankamagames.jerakine.logger.Log;
   import com.ankamagames.jerakine.logger.Logger;
   import com.ankamagames.jerakine.managers.FontManager;
   import com.ankamagames.jerakine.types.Callback;
   import com.ankamagames.jerakine.types.Uri;
   import com.ankamagames.jerakine.types.UserFont;
   import com.ankamagames.jerakine.utils.misc.DescribeTypeCache;
   import com.ankamagames.jerakine.utils.misc.StringUtils;
   import flash.display.BitmapData;
   import flash.display.DisplayObjectContainer;
   import flash.display.Sprite;
   import flash.events.Event;
   import flash.events.MouseEvent;
   import flash.events.TextEvent;
   import flash.filters.BitmapFilter;
   import flash.filters.DropShadowFilter;
   import flash.filters.GlowFilter;
   import flash.geom.Matrix;
   import flash.geom.Point;
   import flash.geom.Rectangle;
   import flash.text.AntiAliasType;
   import flash.text.GridFitType;
   import flash.text.StyleSheet;
   import flash.text.TextField;
   import flash.text.TextFieldAutoSize;
   import flash.text.TextFieldType;
   import flash.text.TextFormat;
   import flash.text.TextLineMetrics;
   import flash.utils.Dictionary;
   import flash.utils.getQualifiedClassName;
   import mx.utils.UIDUtil;
   
   public class Label extends GraphicContainer implements UIComponent, IRectangle, FinalizableUIComponent
   {
      
      public static var HEIGHT_OFFSET:int = 0;
      
      public static var MEMORY_LOG:Dictionary = new Dictionary(true);
      
      protected static const _log:Logger = Log.getLogger(getQualifiedClassName(Label));
      
      private static const VALIGN_NONE:String = ""NONE"";
      
      private static const VALIGN_TOP:String = ""TOP"";
      
      private static const VALIGN_CENTER:String = ""CENTER"";
      
      private static const VALIGN_BOTTOM:String = ""BOTTOM"";
      
      private static const VALIGN_FIXEDHEIGHT:String = ""FIXEDHEIGHT"";
      
      private static const _filterIndex:Dictionary = new Dictionary();
       
      
      protected var _tText:TextField;
      
      private var _cssApplied:Boolean = false;
      
      protected var _sText:String = """";
      
      protected var _sType:String = ""default"";
      
      protected var _parseText:Boolean = true;
      
      private var _binded:Boolean = false;
      
      private var _needToFinalize:Boolean = false;
      
      private var _lastWidth:Number = -1;
      
      private var _uid:String = null;
      
      protected var _sCssUrl:Uri;
      
      protected var _nWidth:uint = 100;
      
      protected var _nHeight:uint = 20;
      
      protected var _bHtmlAllowed:Boolean = true;
      
      protected var _sAntialiasType:String = ""normal"";
      
      protected var _bFixedWidth:Boolean = true;
      
      protected var _hyperlinkEnabled:Boolean = false;
      
      protected var _bFixedHeight:Boolean = true;
      
      protected var _bFixedHeightForMultiline:Boolean = false;
      
      protected var _aStyleObj:Array;
      
      protected var _ssSheet:ExtendedStyleSheet;
      
      protected var _tfFormatter:TextFormat;
      
      protected var _useEmbedFonts:Boolean = true;
      
      protected var _useDefaultFont:Boolean = false;
      
      protected var _useFontResize:Boolean = true;
      
      protected var _nPaddingLeft:int = 0;
      
      protected var _nPaddingRight:int = 0;
      
      protected var _nTextIndent:int = 0;
      
      protected var _verticalOffset:Number = 0.0;
      
      protected var _bDisabled:Boolean;
      
      protected var _nTextHeight:int;
      
      protected var _sVerticalAlign:String = ""none"";
      
      protected var _useExtendWidth:Boolean = false;
      
      protected var _autoResize:Boolean = true;
      
      protected var _useStyleSheet:Boolean = false;
      
      protected var _currentStyleSheet:StyleSheet;
      
      protected var _useCustomFormat:Boolean = false;
      
      protected var _neverIndent:Boolean = false;
      
      protected var _hasHandCursor:Boolean = false;
      
      protected var _shiftClickActivated:Boolean = true;
      
      protected var _forceUppercase:Boolean = false;
      
      private var _useTooltipExtension:Boolean = true;
      
      private var _textFieldTooltipExtension:TextField;
      
      private var _textTooltipExtensionColor:uint;
      
      private var _mouseOverHyperLink:Boolean;
      
      private var _lastHyperLinkId:int;
      
      private var _hyperLinks:Array;
      
      protected var _sCssClass:String;
      
      public function Label()
      {
         super();
         this.aStyleObj = new Array();
         this.createTextField();
         this._tText.type = TextFieldType.DYNAMIC;
         this._tText.selectable = false;
         this._tText.mouseEnabled = false;
         this.useFontResize = this._useFontResize;
         MEMORY_LOG[this] = 1;
      }
      
      public function get text() : String
      {
         return this._tText.text;
      }
      
      public function set text(sValue:String) : void
      {
         if(sValue == null)
         {
            sValue = """";
         }
         if(this._forceUppercase)
         {
            sValue = sValue.toLocaleUpperCase();
         }
         this._sText = sValue;
         if(this._bHtmlAllowed)
         {
            if(this._useStyleSheet)
            {
               this._tText.styleSheet = null;
            }
            this._tText.htmlText = sValue;
            if(!this._useCustomFormat)
            {
               if(this._sCssUrl != null && !this._cssApplied)
               {
                  this.applyCSS(this._sCssUrl);
                  this._cssApplied = true;
               }
               else
               {
                  this.updateCss();
                  if(_bgColor != -1)
                  {
                     this.bgColor = _bgColor;
                  }
               }
            }
         }
         else
         {
            this._tText.text = sValue;
         }
         if(!this._useCustomFormat && !this._sCssClass)
         {
            this.cssClass = ""p"";
         }
         if(this._hyperlinkEnabled)
         {
            HyperlinkFactory.createTextClickHandler(this._tText,this._useStyleSheet);
            HyperlinkFactory.createRollOverHandler(this._tText);
            this.parseLinks();
         }
         if(this._currentStyleSheet)
         {
            if(this._hyperlinkEnabled)
            {
               sValue = HyperlinkFactory.decode(sValue);
               this.parseLinks();
            }
            this._tText.styleSheet = this._currentStyleSheet;
            this._tText.htmlText = sValue;
         }
         if(_finalized && this._autoResize)
         {
            this.resizeText();
         }
      }
      
      public function get htmlText() : String
      {
         return this._tText.htmlText;
      }
      
      public function set htmlText(val:String) : void
      {
         if(this._forceUppercase)
         {
            val = val.toLocaleUpperCase();
         }
         this._tText.htmlText = val;
         if(this._hyperlinkEnabled)
         {
            HyperlinkFactory.createTextClickHandler(this._tText);
            HyperlinkFactory.createRollOverHandler(this._tText);
            this.parseLinks();
         }
      }
      
      public function get parseText() : Boolean
      {
         return this._parseText;
      }
      
      public function set parseText(value:Boolean) : void
      {
         this._parseText = value;
      }
      
      public function get hyperlinkEnabled() : Boolean
      {
         return this._hyperlinkEnabled;
      }
      
      public function get mouseOverHyperLink() : Boolean
      {
         return this._mouseOverHyperLink;
      }
      
      public function set hyperlinkEnabled(bValue:Boolean) : void
      {
         this._hyperlinkEnabled = bValue;
         mouseEnabled = bValue;
         mouseChildren = bValue;
         this._tText.mouseEnabled = bValue;
         if(bValue)
         {
            this._hyperLinks = [];
            this._tText.addEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
            this._tText.addEventListener(MouseEvent.ROLL_OUT,this.hyperlinkRollOut);
         }
         else
         {
            this._tText.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
            this._tText.removeEventListener(MouseEvent.ROLL_OUT,this.hyperlinkRollOut);
         }
      }
      
      public function get useStyleSheet() : Boolean
      {
         return this._useStyleSheet;
      }
      
      public function set useStyleSheet(bValue:Boolean) : void
      {
         this._useStyleSheet = bValue;
      }
      
      public function get useCustomFormat() : Boolean
      {
         return this._useCustomFormat;
      }
      
      public function set useCustomFormat(bValue:Boolean) : void
      {
         this._useCustomFormat = bValue;
      }
      
      public function get shiftClickActivated() : Boolean
      {
         return this._shiftClickActivated;
      }
      
      public function set shiftClickActivated(bValue:Boolean) : void
      {
         this._shiftClickActivated = bValue;
      }
      
      public function get neverIndent() : Boolean
      {
         return this._neverIndent;
      }
      
      public function set neverIndent(bValue:Boolean) : void
      {
         this._neverIndent = bValue;
      }
      
      public function get autoResize() : Boolean
      {
         return this._autoResize;
      }
      
      public function set autoResize(bValue:Boolean) : void
      {
         this._autoResize = bValue;
      }
      
      public function get caretIndex() : int
      {
         return this._tText.caretIndex;
      }
      
      public function set caretIndex(pos:int) : void
      {
         var lastPos:int = 0;
         if(pos == -1)
         {
            lastPos = this._tText.text.length;
            this._tText.setSelection(lastPos,lastPos);
         }
         else
         {
            this._tText.setSelection(pos,pos);
         }
      }
      
      public function selectAll() : void
      {
         this._tText.setSelection(0,this._tText.length);
      }
      
      public function getCharBoundaries(charPos:Number) : Rectangle
      {
         return this._tText.getCharBoundaries(charPos);
      }
      
      public function get type() : String
      {
         return this._sType;
      }
      
      public function set type(sValue:String) : void
      {
         this._sType = sValue;
      }
      
      [Uri]
      public function get css() : Uri
      {
         return this._sCssUrl;
      }
      
      [Uri]
      public function set css(sFile:Uri) : void
      {
         this._cssApplied = false;
         this.applyCSS(sFile);
      }
      
      public function set cssClass(c:String) : void
      {
         this._sCssClass = c == """" ? ""p"" : c;
         this.bindCss();
      }
      
      public function get cssClass() : String
      {
         return this._sCssClass;
      }
      
      public function get antialias() : String
      {
         return this._sAntialiasType;
      }
      
      public function set antialias(s:String) : void
      {
         this._sAntialiasType = s;
         this._tText.antiAliasType = this._sAntialiasType;
      }
      
      public function get thickness() : int
      {
         return this._tText.thickness;
      }
      
      public function set thickness(value:int) : void
      {
         this._tText.thickness = value;
      }
      
      public function get forceUppercase() : Boolean
      {
         return this._forceUppercase;
      }
      
      public function set forceUppercase(value:Boolean) : void
      {
         this._forceUppercase = value;
         var currentText:String = this.text;
         this.text = currentText;
      }
      
      public function set aStyleObj(value:Object) : void
      {
         this._aStyleObj = value as Array;
      }
      
      public function get aStyleObj() : Object
      {
         return this._aStyleObj;
      }
      
      override public function get width() : Number
      {
         return this._useExtendWidth && this._tText.numLines < 2 ? Number(this._tText.textWidth + 7) : Number(this._nWidth);
      }
      
      override public function set width(nValue:Number) : void
      {
         if(nValue == 0)
         {
            return;
         }
         this._nWidth = nValue;
         this._tText.width = this._nWidth;
         super.width = nValue;
         if(!this._bFixedHeight)
         {
            this.bindCss();
         }
         if(_finalized && this._autoResize)
         {
            this.resizeText();
         }
      }
      
      override public function get height() : Number
      {
         return this._nHeight;
      }
      
      override public function set height(nValue:Number) : void
      {
         var valMin:Number = NaN;
         if(!this._tText.multiline)
         {
            valMin = this._tText.textHeight;
            if(nValue < valMin)
            {
               nValue = valMin;
            }
         }
         this._nHeight = nValue;
         this._tText.height = this._nHeight;
         __height = this._nHeight;
         if(_bgColor != -1)
         {
            this.bgColor = _bgColor;
         }
         this.updateAlign();
      }
      
      public function get textWidth() : Number
      {
         return this._tText.textWidth;
      }
      
      public function get textHeight() : Number
      {
         return this._tText.textHeight;
      }
      
      public function get html() : Boolean
      {
         return this._bHtmlAllowed;
      }
      
      public function set html(bValue:Boolean) : void
      {
         this._bHtmlAllowed = bValue;
      }
      
      public function set wordWrap(bWordWrap:Boolean) : void
      {
         this._tText.wordWrap = bWordWrap;
      }
      
      public function get wordWrap() : Boolean
      {
         return this._tText.wordWrap;
      }
      
      public function set multiline(bMultiline:Boolean) : void
      {
         this._tText.multiline = bMultiline;
      }
      
      public function get multiline() : Boolean
      {
         return this._tText.multiline;
      }
      
      public function get border() : Boolean
      {
         return this._tText.border;
      }
      
      public function set border(bValue:Boolean) : void
      {
         this._tText.border = bValue;
      }
      
      public function get fixedWidth() : Boolean
      {
         return this._bFixedWidth;
      }
      
      public function set fixedWidth(bValue:Boolean) : void
      {
         this._bFixedWidth = bValue;
         if(this._bFixedWidth)
         {
            this._tText.autoSize = TextFieldAutoSize.NONE;
         }
         else
         {
            this._tText.autoSize = TextFieldAutoSize.LEFT;
         }
      }
      
      public function get useExtendWidth() : Boolean
      {
         return this._useExtendWidth;
      }
      
      public function set useExtendWidth(v:Boolean) : void
      {
         this._useExtendWidth = v;
      }
      
      public function get hasTooltipExtension() : Boolean
      {
         return this._textFieldTooltipExtension && this._textFieldTooltipExtension.text != """";
      }
      
      public function get fixedHeight() : Boolean
      {
         return this._bFixedHeight;
      }
      
      public function set fixedHeight(bValue:Boolean) : void
      {
         this._bFixedHeight = bValue;
         if(this._tText.wordWrap && bValue)
         {
            _log.warn(""Setting wordWrap to false as fixedHeight has been set to true!"");
         }
         this._tText.wordWrap = !this._bFixedHeight;
      }
      
      public function get fixedHeightForMultiline() : Boolean
      {
         return this._bFixedHeightForMultiline;
      }
      
      public function set fixedHeightForMultiline(bValue:Boolean) : void
      {
         this._bFixedHeightForMultiline = bValue;
      }
      
      override public function set bgColor(nColor:*) : void
      {
         setColorVar(nColor);
         graphics.clear();
         if(bgColor == -1 || !this.width || !this.height)
         {
            return;
         }
         if(_borderColor != -1)
         {
            graphics.lineStyle(1,_borderColor);
         }
         graphics.beginFill(_bgColor,_bgAlpha);
         if(!_bgCornerRadius)
         {
            graphics.drawRect(x - _bgMargin,y,this.width + _bgMargin * 2,this.height + 2);
         }
         else
         {
            graphics.drawRoundRect(this._tText.x - _bgMargin,this._tText.y,this._tText.width + _bgMargin * 2,this._tText.height + 2,_bgCornerRadius,_bgCornerRadius);
         }
         graphics.endFill();
      }
      
      override public function set borderColor(nColor:int) : void
      {
         if(nColor == -1)
         {
            this._tText.border = false;
         }
         else
         {
            this._tText.border = true;
            this._tText.borderColor = nColor;
         }
      }
      
      public function set selectable(bValue:Boolean) : void
      {
         this._tText.selectable = bValue;
      }
      
      public function get length() : uint
      {
         return this._tText.length;
      }
      
      public function set scrollV(nVal:int) : void
      {
         this._tText.scrollV = nVal;
      }
      
      public function get scrollV() : int
      {
         this._tText.getCharBoundaries(0);
         return this._tText.scrollV;
      }
      
      public function get maxScrollV() : int
      {
         this._tText.getCharBoundaries(0);
         return this._tText.maxScrollV;
      }
      
      public function get textfield() : TextField
      {
         return this._tText;
      }
      
      public function get useEmbedFonts() : Boolean
      {
         return this._useEmbedFonts;
      }
      
      public function set useEmbedFonts(b:Boolean) : void
      {
         this._useEmbedFonts = b;
         this._tText.embedFonts = b;
      }
      
      override public function set disabled(bool:Boolean) : void
      {
         if(bool)
         {
            this._hasHandCursor = handCursor;
            handCursor = false;
            mouseEnabled = false;
            this._tText.mouseEnabled = false;
         }
         else
         {
            if(!handCursor)
            {
               handCursor = this._hasHandCursor;
            }
            mouseEnabled = true;
            this._tText.mouseEnabled = true;
         }
         this._bDisabled = bool;
      }
      
      public function get verticalAlign() : String
      {
         return this._sVerticalAlign;
      }
      
      public function set verticalAlign(s:String) : void
      {
         this._sVerticalAlign = s;
         this.updateAlign();
      }
      
      public function get textFormat() : TextFormat
      {
         return this._tfFormatter;
      }
      
      public function set textFormat(tf:TextFormat) : void
      {
         this._tfFormatter = tf;
         this._tText.setTextFormat(this._tfFormatter);
      }
      
      public function set restrict(restrictTo:String) : void
      {
         this._tText.restrict = restrictTo;
      }
      
      public function get restrict() : String
      {
         return this._tText.restrict;
      }
      
      public function set colorText(color:uint) : void
      {
         if(!this._tfFormatter)
         {
            _log.error(""Error. Try to change the size before formatter was initialized."");
            return;
         }
         this._tfFormatter.color = color;
         this._tText.setTextFormat(this._tfFormatter);
         this._tText.defaultTextFormat = this._tfFormatter;
      }
      
      public function get useDefaultFont() : Boolean
      {
         return this._useDefaultFont;
      }
      
      public function set useDefaultFont(value:Boolean) : void
      {
         this._useDefaultFont = value;
      }
      
      public function get useFontResize() : Boolean
      {
         return this._useFontResize;
      }
      
      public function set useFontResize(value:Boolean) : void
      {
         this._useFontResize = value;
         if(this._useFontResize)
         {
            FontManager.getInstance().addEventListener(Event.CHANGE,this.onFontConfigChange,false,0,true);
         }
         else
         {
            FontManager.getInstance().removeEventListener(Event.CHANGE,this.onFontConfigChange,false);
         }
      }
      
      public function setCssColor(color:String, style:String = null) : void
      {
         this.changeCssClassColor(color,style);
      }
      
      public function setCssSize(size:uint, style:String = null) : void
      {
         this.changeCssClassSize(size,style);
      }
      
      public function setCssFont(font:String, style:String = null) : void
      {
         this.changeCssClassFont(font,style);
      }
      
      public function setStyleSheet(styles:StyleSheet) : void
      {
         this._useStyleSheet = true;
         this._currentStyleSheet = styles;
         this._tText.styleSheet = this._currentStyleSheet;
      }
      
      protected function onFontConfigChange(event:Event) : void
      {
         this.bindCss();
      }
      
      public function applyCSS(sFile:Uri) : void
      {
         if(sFile == null)
         {
            return;
         }
         if(sFile == this._sCssUrl && this._tfFormatter)
         {
            this.updateCss();
         }
         else
         {
            this._sCssUrl = sFile;
            CssManager.getInstance().askCss(sFile.uri,new Callback(this.bindCss));
         }
      }
      
      public function setBorderColor(nColor:int) : void
      {
         this._tText.borderColor = nColor;
      }
      
      public function allowTextMouse(bValue:Boolean) : void
      {
         this.mouseChildren = bValue;
         this._tText.mouseEnabled = bValue;
      }
      
      override public function remove() : void
      {
         super.remove();
         if(this._tText && this._tText.parent)
         {
            removeChild(this._tText);
         }
         if(this._uid)
         {
            TooltipManager.hide(""TextExtension"" + this._uid);
         }
         if(this._tText)
         {
            this._tText.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
            this._tText.removeEventListener(MouseEvent.ROLL_OUT,this.hyperlinkRollOut);
            this._tText.removeEventListener(TextEvent.LINK,this.onTextClick);
            HyperlinkFactory.deactiveSmallHyperlink(this._tText);
            HyperlinkFactory.removeTextClickHandler(this._tText);
            HyperlinkFactory.removeRollOverHandler(this._tText);
         }
         if(this._textFieldTooltipExtension)
         {
            this._textFieldTooltipExtension.removeEventListener(MouseEvent.ROLL_OVER,this.onTooltipExtensionOver);
            this._textFieldTooltipExtension.removeEventListener(MouseEvent.ROLL_OUT,this.onTooltipExtensionOut);
            this._textFieldTooltipExtension.removeEventListener(MouseEvent.MOUSE_WHEEL,this.onTooltipExtensionOut);
         }
         FontManager.getInstance().removeEventListener(Event.CHANGE,this.onFontConfigChange,false);
      }
      
      override public function free() : void
      {
         super.free();
         this._sType = ""default"";
         this._nWidth = 100;
         this._nHeight = 20;
         this._bHtmlAllowed = true;
         this._sAntialiasType = AntiAliasType.NORMAL;
         this._bFixedWidth = true;
         this._bFixedHeight = true;
         this._bFixedHeightForMultiline = false;
         this._ssSheet = null;
         this._useEmbedFonts = true;
         this._nPaddingLeft = 0;
         this._nPaddingRight = 0;
         this._nTextIndent = 0;
         this._bDisabled = false;
         this._nTextHeight = 0;
         this._sVerticalAlign = ""none"";
         this._useExtendWidth = false;
         this._sCssClass = null;
         this._tText.type = TextFieldType.DYNAMIC;
         this._tText.selectable = false;
      }
      
      private function createTextField() : void
      {
         this._tText = new TextField();
         this._tText.addEventListener(TextEvent.LINK,this.onTextClick);
         addChild(this._tText);
      }
      
      private function changeCssClassColor(color:String, style:String = null) : void
      {
         var i:* = undefined;
         if(style)
         {
            if(this.aStyleObj[style] == null)
            {
               this.aStyleObj[style] = new Object();
            }
            this.aStyleObj[style].color = color;
            if(this._ssSheet)
            {
               this._tfFormatter = this._ssSheet.transform(this.aStyleObj[style]);
               this._tText.setTextFormat(this._tfFormatter);
               this._tText.defaultTextFormat = this._tfFormatter;
            }
         }
         else
         {
            for each(i in this.aStyleObj)
            {
               i.color = color;
            }
         }
      }
      
      private function changeCssClassSize(size:uint, style:String = null) : void
      {
         var currentStyleSheet:StyleSheet = null;
         var i:* = undefined;
         if(style)
         {
            if(this.aStyleObj[style] == null)
            {
               this.aStyleObj[style] = new Object();
            }
            this.aStyleObj[style].fontSize = size;
            if(this._ssSheet)
            {
               currentStyleSheet = this._tText.styleSheet;
               this._tText.styleSheet = null;
               this._tfFormatter = this._ssSheet.transform(this.aStyleObj[style]);
               this._tText.setTextFormat(this._tfFormatter);
               this._tText.defaultTextFormat = this._tfFormatter;
               this._tText.styleSheet = currentStyleSheet;
            }
         }
         else
         {
            for each(i in this.aStyleObj)
            {
               i.fontSize = size;
            }
         }
      }
      
      private function changeCssClassFont(font:String, style:String = null) : void
      {
         var i:* = undefined;
         if(style)
         {
            if(this.aStyleObj[style] == null)
            {
               this.aStyleObj[style] = new Object();
            }
            this.aStyleObj[style].fontFamily = font;
         }
         else
         {
            for each(i in this.aStyleObj)
            {
               i.fontFamily = font;
            }
         }
      }
      
      public function appendText(sTxt:String, style:String = null) : void
      {
         var textFormat:TextFormat = null;
         if(this._forceUppercase)
         {
            sTxt = sTxt.toLocaleUpperCase();
         }
         if(style && this.aStyleObj[style] && this._ssSheet)
         {
            if(this._tText.filters.length)
            {
               this._tText.filters = new Array();
            }
            textFormat = this._ssSheet.transform(this.aStyleObj[style]);
            if(!textFormat.bold)
            {
               textFormat.bold = false;
            }
            this._tText.defaultTextFormat = textFormat;
         }
         if(this._hyperlinkEnabled)
         {
            sTxt = HyperlinkFactory.decode(sTxt);
         }
         this._tText.htmlText += sTxt;
         if(this._hyperlinkEnabled)
         {
            this.parseLinks();
         }
      }
      
      public function activeSmallHyperlink() : void
      {
         HyperlinkFactory.activeSmallHyperlink(this._tText);
      }
      
      private function bindCss() : void
      {
         var styleToDisplay:String = null;
         var s:String = null;
         var effectName:String = null;
         var filtersTmp:Array = null;
         var filterRef:Dictionary = null;
         var cssKey:String = null;
         var oldCssUrl:Uri = null;
         var filter:BitmapFilter = null;
         var valueString:String = null;
         var value:* = undefined;
         var oldSize:Number = NaN;
         var font:String = null;
         if(!this._sCssUrl)
         {
            if(this._needToFinalize)
            {
               this.finalize();
            }
            return;
         }
         var oldCss:ExtendedStyleSheet = this._ssSheet;
         this._ssSheet = CssManager.getInstance().getCss(this._sCssUrl.uri);
         if(!this._ssSheet)
         {
            if(oldCss == null)
            {
               if(this._needToFinalize)
               {
                  this.finalize();
               }
               return;
            }
            this._ssSheet = oldCss;
            oldCssUrl = this._sCssUrl;
            this._sCssUrl = null;
            this.applyCSS(oldCssUrl);
         }
         var currentStyleSheet:StyleSheet = this._tText.styleSheet;
         this._tText.styleSheet = null;
         this.aStyleObj = new Array();
         for each(s in this._ssSheet.styleNames)
         {
            if(!styleToDisplay || s == this._sCssClass || this._sCssClass != styleToDisplay && s == ""p"")
            {
               styleToDisplay = s;
            }
            if(this._ssSheet != oldCss || !this.aStyleObj[s])
            {
               this.aStyleObj[s] = this._ssSheet.getStyle(s);
            }
         }
         filtersTmp = [];
         filterRef = new Dictionary();
         for(cssKey in this.aStyleObj[styleToDisplay])
         {
            effectName = cssKey.indexOf(""shadow"") != -1 ? ""shadow"" : null;
            effectName = !effectName && cssKey.indexOf(""glow"") != -1 ? ""glow"" : effectName;
            if(effectName)
            {
               if(!filterRef[effectName])
               {
                  if(effectName == ""shadow"")
                  {
                     filter = new DropShadowFilter();
                  }
                  else if(effectName == ""glow"")
                  {
                     filter = new GlowFilter();
                  }
                  this.buildFilterIndex(filter);
                  filtersTmp.push(filter);
                  filterRef[effectName] = filter;
               }
               else
               {
                  filter = filterRef[effectName];
               }
               try
               {
                  valueString = this.aStyleObj[styleToDisplay][cssKey];
                  if(valueString.charAt(0) == ""#"")
                  {
                     value = parseInt(valueString.substr(1),16);
                  }
                  else
                  {
                     value = parseFloat(valueString);
                  }
                  filter[_filterIndex[getQualifiedClassName(filter)][cssKey.substr(effectName.length).toLowerCase()]] = value;
               }
               catch(e:Error)
               {
                  _log.error(e);
               }
            }
         }
         filters = filtersTmp;
         if(this.aStyleObj[styleToDisplay][""useEmbedFonts""])
         {
            this._useEmbedFonts = this.aStyleObj[styleToDisplay][""useEmbedFonts""] == ""true"";
         }
         if(this.aStyleObj[styleToDisplay][""paddingLeft""])
         {
            this._nPaddingLeft = parseInt(this.aStyleObj[styleToDisplay][""paddingLeft""]);
         }
         if(this.aStyleObj[styleToDisplay][""paddingRight""])
         {
            this._nPaddingRight = parseInt(this.aStyleObj[styleToDisplay][""paddingRight""]);
         }
         if(this.aStyleObj[styleToDisplay][""verticalHeight""])
         {
            this._nTextHeight = parseInt(this.aStyleObj[styleToDisplay][""verticalHeight""]);
         }
         if(this.aStyleObj[styleToDisplay][""verticalAlign""])
         {
            this.verticalAlign = this.aStyleObj[styleToDisplay][""verticalAlign""];
         }
         if(this.aStyleObj[styleToDisplay][""thickness""])
         {
            this._tText.thickness = this.aStyleObj[styleToDisplay][""thickness""];
         }
         this._tText.gridFitType = GridFitType.PIXEL;
         this._tText.htmlText = !!this._sText ? this._sText : this.htmlText;
         this._tfFormatter = this._ssSheet.transform(this.aStyleObj[styleToDisplay]);
         if(this.aStyleObj[styleToDisplay][""leading""])
         {
            this._tfFormatter.leading = this.aStyleObj[styleToDisplay][""leading""];
         }
         if(this.aStyleObj[styleToDisplay][""letterSpacing""])
         {
            this._tfFormatter.letterSpacing = parseFloat(this.aStyleObj[styleToDisplay][""letterSpacing""]);
         }
         if(this.aStyleObj[styleToDisplay][""kerning""])
         {
            this._tfFormatter.kerning = this.aStyleObj[styleToDisplay][""kerning""] == ""true"";
         }
         if(!this._neverIndent)
         {
            this._tfFormatter.indent = this._nTextIndent;
         }
         this._tfFormatter.leftMargin = this._nPaddingLeft;
         this._tfFormatter.rightMargin = this._nPaddingRight;
         var fontInfo:UserFont = FontManager.getInstance().getFontInfo(this._tfFormatter.font,this._useDefaultFont);
         if(this._useEmbedFonts)
         {
            if(fontInfo)
            {
               oldSize = this._tfFormatter.size != null ? Number(Number(this._tfFormatter.size)) : Number(12);
               if(fontInfo.maxSize != UserFont.FONT_SIZE_NO_MAX && this._tfFormatter.size < fontInfo.maxSize)
               {
                  this._tfFormatter.size = Math.min(Math.round(int(this._tfFormatter.size) * fontInfo.sizeMultiplicator),fontInfo.maxSize != UserFont.FONT_SIZE_NO_MAX ? Number(fontInfo.maxSize) : Number(1000));
                  this._verticalOffset = ((this._tfFormatter.size != null ? Number(this._tfFormatter.size) : 12) - oldSize) * fontInfo.verticalOffset;
               }
               this._tfFormatter.font = fontInfo.className;
               this._tText.defaultTextFormat.font = fontInfo.className;
               this._tText.embedFonts = true;
               this._tText.antiAliasType = AntiAliasType.ADVANCED;
               this._tText.sharpness = fontInfo.sharpness;
               if(this._tfFormatter.letterSpacing < fontInfo.letterSpacing)
               {
                  this._tfFormatter.letterSpacing = fontInfo.letterSpacing;
               }
               if(this._tfFormatter.letterSpacing == null)
               {
                  this._tfFormatter.letterSpacing = 0.0001;
               }
            }
            else if(this._tfFormatter)
            {
               _log.warn(""System font ["" + this._tfFormatter.font + ""] used (in "" + (!!getUi() ? getUi().name : ""unknow"") + "", from "" + this._sCssUrl.uri + "")"");
            }
            else
            {
               _log.fatal(""Erreur de formattage."");
            }
         }
         else
         {
            font = !!fontInfo ? fontInfo.realName : """";
            this._tfFormatter.font = font != """" ? font : this._tfFormatter.font;
            this._tText.embedFonts = false;
         }
         this._tText.setTextFormat(this._tfFormatter);
         this._tText.defaultTextFormat = this._tfFormatter;
         if(this._hyperlinkEnabled)
         {
            HyperlinkFactory.createTextClickHandler(this._tText,true);
            HyperlinkFactory.createRollOverHandler(this._tText);
            this.parseLinks();
         }
         this._tText.styleSheet = currentStyleSheet;
         if(this._nTextHeight)
         {
            this._tText.height = this._nTextHeight;
            this._tText.y += this._nHeight / 2 - this._tText.height / 2;
         }
         else if(!this._bFixedHeight)
         {
            this._tText.height = this._tText.textHeight + 5;
            this._nHeight = this._tText.height;
         }
         else
         {
            this._tText.height = this._nHeight;
         }
         if(this._useExtendWidth)
         {
            this._tText.width = this._tText.textWidth + 7;
            this._nWidth = this._tText.width;
         }
         if(_bgColor != -1)
         {
            this.bgColor = _bgColor;
         }
         this.updateAlign();
         if(this._useExtendWidth && getUi())
         {
            getUi().render();
         }
         this._binded = true;
         this.updateTooltipExtensionStyle();
         if(this._needToFinalize)
         {
            this.finalize();
         }
      }
      
      public function updateCss() : void
      {
         if(!this._tfFormatter)
         {
            return;
         }
         this._tText.setTextFormat(this._tfFormatter);
         this._tText.defaultTextFormat = this._tfFormatter;
         this.updateTooltipExtensionStyle();
         if(!this._bFixedHeight)
         {
            this._tText.height = this._tText.textHeight + 5;
            this._nHeight = this._tText.height;
         }
         else
         {
            this._tText.height = this._nHeight;
         }
         if(this._useExtendWidth)
         {
            this._tText.width = this._tText.textWidth + 7;
            this._nWidth = this._tText.width;
         }
         if(_bgColor != -1)
         {
            this.bgColor = _bgColor;
         }
         this.updateAlign();
         if(this._useExtendWidth && getUi())
         {
            getUi().render();
         }
      }
      
      public function updateTextFormatProperty(pPropertyName:String, pPropertyValue:*) : void
      {
         this._tfFormatter[pPropertyName] = pPropertyValue;
         this.updateCss();
      }
      
      public function fullSize(width:int) : void
      {
         this.removeTooltipExtension();
         this._nWidth = width;
         this._tText.width = width;
         var tHeight:uint = this._tText.textHeight + 8;
         this._tText.height = tHeight;
         this._nHeight = tHeight;
      }
      
      public function fullWidthAndHeight(maxWidth:uint = 0, offsetWidth:uint = 5) : void
      {
         this._nWidth = int(this._tText.textWidth + offsetWidth);
         this._tText.width = this._nWidth;
         if(maxWidth > 0)
         {
            this._nWidth = maxWidth;
            this._tText.width = maxWidth;
            if(this._tText.textWidth < maxWidth)
            {
               this._tText.width = this._tText.textWidth + 10;
            }
         }
         this._nHeight = this._tText.textHeight + 8;
         this._tText.height = this._nHeight;
      }
      
      public function fullWidth(maxWidth:uint = 0, offsetWidth:uint = 5) : void
      {
         this._nWidth = int(this._tText.textWidth + offsetWidth);
         this._tText.width = this._nWidth;
         if(maxWidth > 0)
         {
            this._nWidth = maxWidth;
            this._tText.width = maxWidth;
            if(this._tText.textWidth < maxWidth)
            {
               this._tText.width = this._tText.textWidth + 10;
            }
         }
      }
      
      public function resizeText() : void
      {
         var needTooltipExtension:Boolean = false;
         var currentTextFieldWidth:int = 0;
         this.removeTooltipExtension();
         if((this._bFixedHeight && !this._tText.multiline || this._bFixedHeightForMultiline) && this._tText.autoSize == ""none"" && this._tfFormatter)
         {
            needTooltipExtension = false;
            currentTextFieldWidth = this._tText.width;
            if(this._tText.textWidth > currentTextFieldWidth + 1 || this._tText.textHeight > this._tText.height || this._bFixedHeightForMultiline && this._tText.textHeight > this.height)
            {
               if(this._useTooltipExtension)
               {
                  needTooltipExtension = true;
               }
               else
               {
                  _log.warn(""Attention : Ce texte est beaucoup trop long pour entrer dans ce TextField (Texte : "" + this._tText.text + "")"");
               }
            }
            if(needTooltipExtension && (!this.multiline && this._bFixedHeight || this._bFixedHeightForMultiline))
            {
               this.addTooltipExtension();
            }
            else if(this._lastWidth != this._tText.width)
            {
               this._lastWidth = this._tText.width;
            }
         }
      }
      
      public function truncateText(pMaxHeight:Number, pCleanTruncature:Boolean = true) : void
      {
         var numLines:int = 0;
         var nbVisibleLines:int = 0;
         var nbVisibleChars:int = 0;
         var i:int = 0;
         var h:Number = NaN;
         var lineHeight:Number = NaN;
         var lineBreakIndex:int = 0;
         var periodIndex:int = 0;
         this._nHeight = __height = this._tText.height = pMaxHeight;
         if(this._tText.wordWrap && this._tText.numLines > 0)
         {
            numLines = this._tText.numLines;
            h = 4;
            lineHeight = this._tText.getLineMetrics(0).height;
            for(i = 0; i < numLines; i++)
            {
               h += lineHeight;
               if(h >= this._tText.height)
               {
                  break;
               }
               nbVisibleLines++;
               nbVisibleChars += this._tText.getLineLength(i);
            }
            this._tText.text = this._tText.text.substr(0,nbVisibleChars);
            if(pCleanTruncature)
            {
               lineBreakIndex = this._tText.text.lastIndexOf(String.fromCharCode(10));
               periodIndex = this._tText.text.lastIndexOf(""."");
               if(lineBreakIndex != -1 || periodIndex != -1)
               {
                  this._tText.text = this._tText.text.substring(0,Math.max(lineBreakIndex,periodIndex));
                  this._tText.appendText("" ("" + String.fromCharCode(8230) + "")"");
                  this._nHeight = __height = this._tText.height = this._tText.height - (nbVisibleLines - this._tText.numLines) * lineHeight;
               }
               else
               {
                  this.addEllipsis();
               }
            }
            else
            {
               this.addEllipsis();
            }
         }
      }
      
      public function removeTooltipExtension() : void
      {
         if(this._textFieldTooltipExtension)
         {
            removeChild(this._textFieldTooltipExtension);
            this._tText.width = __width + int(this._textFieldTooltipExtension.width + 2);
            __width = this._tText.width;
            this._textFieldTooltipExtension.removeEventListener(MouseEvent.ROLL_OVER,this.onTooltipExtensionOver);
            this._textFieldTooltipExtension.removeEventListener(MouseEvent.ROLL_OUT,this.onTooltipExtensionOut);
            this._textFieldTooltipExtension = null;
         }
      }
      
      private function buildFilterIndex(target:BitmapFilter) : void
      {
         var field:String = null;
         var className:String = getQualifiedClassName(target);
         if(_filterIndex[className])
         {
            return;
         }
         var index:Dictionary = new Dictionary();
         for each(field in DescribeTypeCache.getVariables(target))
         {
            index[field.toLowerCase()] = field;
         }
         _filterIndex[className] = index;
      }
      
      private function addEllipsis() : void
      {
         var i:int = 0;
         var nbSpaces:int = 0;
         if(this._tText.text.length - 3 > 0)
         {
            this._tText.text = this._tText.text.substr(0,this._tText.text.length - 3);
            i = this._tText.text.length - 1;
            while(i >= 0 && this._tText.text.charAt(i) == "" "")
            {
               nbSpaces++;
               i--;
            }
            if(nbSpaces > 0)
            {
               this._tText.text = this._tText.text.substr(0,this._tText.text.length - nbSpaces);
            }
            this._tText.appendText(String.fromCharCode(8230));
         }
      }
      
      public function addTooltipExtension() : void
      {
         this._textFieldTooltipExtension = new TextField();
         this._textFieldTooltipExtension.selectable = false;
         this._textFieldTooltipExtension.height = 1;
         this._textFieldTooltipExtension.width = 1;
         this._textFieldTooltipExtension.autoSize = TextFieldAutoSize.LEFT;
         this.updateTooltipExtensionStyle();
         this._textFieldTooltipExtension.text = ""..."";
         this._textFieldTooltipExtension.name = ""extension_"" + name;
         addChild(this._textFieldTooltipExtension);
         var w:int = this._textFieldTooltipExtension.width + 2;
         this._tText.width -= w;
         __width = this._tText.width;
         this._textFieldTooltipExtension.x = this._tText.width;
         this._textFieldTooltipExtension.y = this._tText.y + this._tText.height - this._textFieldTooltipExtension.textHeight - 10;
         if(!this._tText.wordWrap)
         {
            this._textFieldTooltipExtension.y = this._tText.y;
            this._tText.height = this._tText.textHeight + 3;
            __height = this._tText.height;
         }
         else if(this._bFixedHeightForMultiline)
         {
            this._tText.height = this.height + 3;
            __height = this._tText.height;
            switch(this._sVerticalAlign.toUpperCase())
            {
               case VALIGN_CENTER:
                  this._tText.y = (this.height - this._tText.height) / 2;
                  break;
               case VALIGN_BOTTOM:
                  this._tText.y = this.height - this._tText.height;
                  break;
               default:
                  this._tText.y = 0;
            }
            this._textFieldTooltipExtension.y = this._tText.y + this.height - this._textFieldTooltipExtension.textHeight;
         }
         var target:DisplayObjectContainer = this;
         for(var i:int = 0; i < 4; i++)
         {
            if(target is ButtonContainer)
            {
               (target as ButtonContainer).mouseChildren = true;
               break;
            }
            target = target.parent;
            if(!target)
            {
               break;
            }
         }
         this._textFieldTooltipExtension.addEventListener(MouseEvent.ROLL_OVER,this.onTooltipExtensionOver,false,0,true);
         this._textFieldTooltipExtension.addEventListener(MouseEvent.ROLL_OUT,this.onTooltipExtensionOut,false,0,true);
         this._textFieldTooltipExtension.addEventListener(MouseEvent.MOUSE_WHEEL,this.onTooltipExtensionOut,false,0,true);
      }
      
      private function updateTooltipExtensionStyle() : void
      {
         if(!this._textFieldTooltipExtension)
         {
            return;
         }
         this._textFieldTooltipExtension.embedFonts = this._tText.embedFonts;
         this._textFieldTooltipExtension.defaultTextFormat = this._tfFormatter;
         this._textFieldTooltipExtension.setTextFormat(this._tfFormatter);
         this._textTooltipExtensionColor = uint(this._tfFormatter.color);
         this._textFieldTooltipExtension.textColor = this._textTooltipExtensionColor;
      }
      
      private function onTextClick(e:TextEvent) : void
      {
         e.stopPropagation();
         Berilia.getInstance().handler.process(new TextClickMessage(this,e.text));
      }
      
      protected function updateAlign() : void
      {
         if(!this._tText.textHeight)
         {
            return;
         }
         var h:int = 0;
         for(var i:int = 0; i < this._tText.numLines; i++)
         {
            h += TextLineMetrics(this._tText.getLineMetrics(i)).height + TextLineMetrics(this._tText.getLineMetrics(i)).leading + TextLineMetrics(this._tText.getLineMetrics(i)).descent;
         }
         this._tText.y = 0;
         switch(this._sVerticalAlign.toUpperCase())
         {
            case VALIGN_CENTER:
               this._tText.height = h;
               this._tText.y = (this.height - this._tText.height) / 2;
               break;
            case VALIGN_BOTTOM:
               this._tText.height = this.height;
               this._tText.y = this.height - h;
               break;
            case VALIGN_TOP:
               this._tText.height = h;
               this._tText.y = 0;
               break;
            case VALIGN_FIXEDHEIGHT:
               if(!this._tText.wordWrap || this._tText.multiline)
               {
                  this._tText.height = this._tText.textHeight + HEIGHT_OFFSET;
               }
               this._tText.y = 0;
               break;
            case VALIGN_NONE:
               if(!this._tText.wordWrap || this._tText.multiline)
               {
                  this._tText.height = this._tText.textHeight + 4 + HEIGHT_OFFSET;
               }
               this._tText.y = 0;
         }
         if(this._tfFormatter && FontManager.getInstance().getFontInfo(this._tfFormatter.font))
         {
            this._tText.y += this._verticalOffset;
         }
      }
      
      private function onTooltipExtensionOver(e:MouseEvent) : void
      {
         var docMain:Sprite = Berilia.getInstance().docMain;
         if(this._uid == null)
         {
            this._uid = UIDUtil.createUID();
         }
         TooltipManager.show(new TextTooltipInfo(this._tText.text),this,UiModuleManager.getInstance().getModule(""Ankama_Tooltips""),false,""TextExtension"" + this._uid,LocationEnum.POINT_TOP,LocationEnum.POINT_BOTTOM,20,true,null,TooltipManager.defaultTooltipUiScript,null,""TextInfo"" + this._uid);
         this._textFieldTooltipExtension.textColor = XmlConfig.getInstance().getEntry(""colors.hyperlink.link"");
      }
      
      private function onTooltipExtensionOut(e:MouseEvent = null) : void
      {
         TooltipManager.hide(""TextExtension"" + this._uid);
         this._textFieldTooltipExtension.textColor = this._textTooltipExtensionColor;
      }
      
      override public function finalize() : void
      {
         var ui:UiRootContainer = null;
         if(this._binded)
         {
            if(this._autoResize)
            {
               this.resizeText();
            }
            if(this._hyperlinkEnabled)
            {
               HyperlinkFactory.createTextClickHandler(this._tText);
               HyperlinkFactory.createRollOverHandler(this._tText);
               this.parseLinks();
            }
            _finalized = true;
            super.finalize();
            ui = getUi();
            if(ui)
            {
               ui.iAmFinalized(this);
            }
         }
         else
         {
            this._needToFinalize = true;
         }
      }
      
      public function get bmpText() : BitmapData
      {
         var m:Matrix = new Matrix();
         var bmpdt:BitmapData = new BitmapData(this.width,this.height,true,16711680);
         bmpdt.draw(this._tText,m,null,null,null,true);
         return bmpdt;
      }
      
      private function parseLinks() : void
      {
         var textrun:Object = null;
         var textrunText:String = null;
         var openSquareBrackets:Array = null;
         var closeSquareBrackets:Array = null;
         var nbBrackets:int = 0;
         var i:int = 0;
         var j:int = 0;
         var textruns:Array = this._tText.getTextRuns();
         var nbRuns:int = textruns.length;
         this._lastHyperLinkId = -1;
         this._hyperLinks.length = 0;
         for(i = 0; i < nbRuns; i++)
         {
            textrun = textruns[i];
            if(textrun.textFormat && textrun.textFormat.url.length > 0)
            {
               textrunText = this._tText.text.substring(textrun.beginIndex,textrun.endIndex);
               openSquareBrackets = StringUtils.getAllIndexOf(""["",textrunText);
               closeSquareBrackets = StringUtils.getAllIndexOf(""]"",textrunText);
               if(openSquareBrackets.length > 1 && openSquareBrackets.length == closeSquareBrackets.length)
               {
                  nbBrackets = openSquareBrackets.length;
                  for(j = 0; j < nbBrackets; j++)
                  {
                     this._hyperLinks.push({
                        ""beginIndex"":textrun.beginIndex + openSquareBrackets[j],
                        ""endIndex"":textrun.beginIndex + closeSquareBrackets[j],
                        ""textFormat"":textrun.textFormat
                     });
                  }
               }
               else
               {
                  this._hyperLinks.push(textrun);
               }
            }
         }
      }
      
      private function getHyperLinkId(pCharIndex:int) : int
      {
         var i:int = 0;
         var nbLinks:int = this._hyperLinks.length;
         for(i = 0; i < nbLinks; i++)
         {
            if(pCharIndex >= this._hyperLinks[i].beginIndex && pCharIndex <= this._hyperLinks[i].endIndex)
            {
               return i;
            }
         }
         return -1;
      }
      
      private function onMouseMove(pEvent:MouseEvent) : void
      {
         var charIndex:int = 0;
         var textHeight:Number = NaN;
         var nbVisibleLines:int = 0;
         var lineHeight:Number = NaN;
         var i:int = 0;
         var numLines:int = 0;
         var bottomMargin:Number = NaN;
         var labelGlobalPos:Point = null;
         var mouseOverText:Boolean = false;
         var hyperLinkId:int = 0;
         var url:String = null;
         var params:Array = null;
         var type:String = null;
         var posY:int = 0;
         var data:String = null;
         if(this._tText.length > 0)
         {
            charIndex = this._tText.getCharIndexAtPoint(pEvent.localX,pEvent.localY);
            textHeight = 4;
            lineHeight = this._tText.getLineMetrics(0).height;
            numLines = this._tText.numLines;
            for(i = 0; i < numLines; i++)
            {
               textHeight += lineHeight;
               if(textHeight > this._tText.height)
               {
                  break;
               }
               nbVisibleLines++;
            }
            bottomMargin = this._tText.height - nbVisibleLines * lineHeight;
            labelGlobalPos = localToGlobal(new Point(x,y));
            mouseOverText = pEvent.stageY > labelGlobalPos.y + this._tText.height - bottomMargin ? false : true;
            if(mouseOverText && charIndex != -1)
            {
               hyperLinkId = this.getHyperLinkId(charIndex);
               url = hyperLinkId >= 0 ? this._hyperLinks[hyperLinkId].textFormat.url : null;
               if(url)
               {
                  if(this._mouseOverHyperLink && (this._lastHyperLinkId >= 0 && hyperLinkId != this._lastHyperLinkId))
                  {
                     this._mouseOverHyperLink = true;
                     this.hyperlinkRollOut();
                  }
                  if(!this._mouseOverHyperLink)
                  {
                     params = url.replace(""event:"","""").split("","");
                     type = params.shift();
                     posY = labelGlobalPos.y + this._tText.getCharBoundaries(charIndex).y;
                     data = type + "","" + Math.round(pEvent.stageX) + "","" + Math.round(posY) + "","" + params.join("","");
                     this._tText.dispatchEvent(new LinkInteractionEvent(LinkInteractionEvent.ROLL_OVER,data));
                     this._mouseOverHyperLink = true;
                     this._lastHyperLinkId = hyperLinkId;
                  }
               }
               else
               {
                  this.hyperlinkRollOut();
               }
            }
            else
            {
               this.hyperlinkRollOut();
            }
         }
      }
      
      private function hyperlinkRollOut(pEvent:MouseEvent = null) : void
      {
         if(pEvent || this._mouseOverHyperLink)
         {
            TooltipManager.hideAll();
            this._tText.dispatchEvent(new LinkInteractionEvent(LinkInteractionEvent.ROLL_OUT));
         }
         this._mouseOverHyperLink = false;
      }
   }
}
",12463,False,2440.17494110476,median
"/*

  UserPtr.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

  Requires -DU8X8_WITH_USER_PTR

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list

void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
  u8g2.setUserPtr((void *)""User Ptr Data"");
}

void loop(void) {
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_ncenR12_tr);
    u8g2.drawStr(0,24, (char *)u8g2.getUserPtr());
  } while ( u8g2.nextPage() );
  delay(1000);
}

",16179,True,5016.238813357618,median
"package com.company.assembleegameclient.objects {
import com.company.assembleegameclient.map.Camera;
import com.company.assembleegameclient.map.Square;
import com.company.assembleegameclient.map.mapoverlay.CharacterStatusText;
import com.company.assembleegameclient.objects.particles.HealingEffect;
import com.company.assembleegameclient.objects.particles.LevelUpEffect;
import com.company.assembleegameclient.parameters.Parameters;
import com.company.assembleegameclient.parameters.Parameters;
import com.company.assembleegameclient.sound.SoundEffectLibrary;
import com.company.assembleegameclient.tutorial.Tutorial;
import com.company.assembleegameclient.tutorial.doneAction;
import com.company.assembleegameclient.util.AnimatedChar;
import com.company.assembleegameclient.util.ConditionEffect;
import com.company.assembleegameclient.util.FameUtil;
import com.company.assembleegameclient.util.FreeList;
import com.company.assembleegameclient.util.MaskedImage;
import com.company.assembleegameclient.util.TextureRedrawer;
import com.company.assembleegameclient.util.redrawers.GlowRedrawer;
import com.company.util.CachingColorTransformer;
import com.company.util.ConversionUtil;
import com.company.util.GraphicsUtil;
import com.company.util.IntPoint;
import com.company.util.MoreColorUtil;
import com.company.util.PointUtil;
import com.company.util.Trig;

import flash.display.BitmapData;
import flash.display.GraphicsPath;
import flash.display.GraphicsSolidFill;
import flash.display.IGraphicsData;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
import flash.utils.getTimer;

import kabam.rotmg.assets.services.CharacterFactory;
import kabam.rotmg.chat.model.ChatMessage;
import kabam.rotmg.constants.ActivationType;
import kabam.rotmg.constants.GeneralConstants;
import kabam.rotmg.constants.UseType;
import kabam.rotmg.core.StaticInjectorContext;
import kabam.rotmg.game.model.PotionInventoryModel;
import kabam.rotmg.game.signals.AddTextLineSignal;
import kabam.rotmg.game.view.components.QueuedStatusText;
import kabam.rotmg.messaging.impl.data.StatData;
import kabam.rotmg.stage3D.GraphicsFillExtra;
import kabam.rotmg.text.model.NumberKey;
import kabam.rotmg.text.model.TextKey;
import kabam.rotmg.text.view.BitmapTextFactory;
import kabam.rotmg.text.view.stringBuilder.LineBuilder;
import kabam.rotmg.text.view.stringBuilder.StaticStringBuilder;
import kabam.rotmg.text.view.stringBuilder.StringBuilder;
import kabam.rotmg.ui.model.TabStripModel;

import org.swiftsuspenders.Injector;

public class Player extends Character {

    public static const MS_BETWEEN_TELEPORT:int = 10000;
    private static const MOVE_THRESHOLD:Number = 0.4;
    private static const NEARBY:Vector.<Point> = new <Point>[new Point(0, 0), new Point(1, 0), new Point(0, 1), new Point(1, 1)];
    private static const RANK_OFFSET_MATRIX:Matrix = new Matrix(1, 0, 0, 1, 2, 2);
    private static const NAME_OFFSET_MATRIX:Matrix = new Matrix(1, 0, 0, 1, 20, 1);
    private static const MIN_MOVE_SPEED:Number = 0.004;
    private static const MAX_MOVE_SPEED:Number = 0.0096;
    private static const MIN_ATTACK_MULT:Number = 0.5;
    private static const MAX_ATTACK_MULT:Number = 2;
    private static const LOW_HEALTH_CT_OFFSET:int = 128;

    private static var lowHealthCT:Dictionary = new Dictionary();
    public static var empiresCoin_:int = 0;
    public static var accountType_:int = 0;
    public static var isAdmin:Boolean = false;
    public static var isMod:Boolean = false;
    private static var newP:Point = new Point();

    public var petObjectId:int = 0;
    public var petHpHealingAverageMin:int = 0;
    public var petHpHealingAverageMax:int = 0;
    public var petHpHealingAverageBonus:int = 0;
    public var petMpHealingAverageMin:int = 0;
    public var petMpHealingAverageMax:int = 0;
    public var petMpHealingAverageBonus:int = 0;
    public var petAttackCooldown:int = 0;
    public var petAttackChance:int = 0;
    public var petAttackDamageMin:int = 0;
    public var petAttackDamageMax:int = 0;

    public var isTrading:Boolean = false;
    public var xpTimer:int;
    public var skinId:int;
    public var skin:AnimatedChar;
    public var isShooting:Boolean;
    public var accountId_:String = """";
    public var credits_:int = 0;
    public var tokens_:int = 0;
    public var numStars_:int = 0;
    public var fame_:Number = 0;
    public var nameChosen_:Boolean = false;
    public var currFame_:Number = 0;
    public var nextClassQuestFame_:Number = -1;
    public var guildName_:String = null;
    public var guildRank_:int = -1;
    public var isFellowGuild_:Boolean = false;
    public var breath_:int = -1;
    public var maxMP_:int = 200;
    public var mp_:Number = 0;
    public var nextLevelExp_:Number = 1000;
    public var nextAttackExp_:Number = 1000;
    public var nextDefenseExp_:Number = 1000;
    public var exp_:Number = 0;
    public var attackExp_:Number = 0;
    public var defenseExp_:Number = 0;
    public var attack_:String = null;
    public var speed_:String = null;
    public var dexterity_:String = null;
    public var vitality_:String = null;
    public var wisdom_:String = null;
    public var maxHPBoost_:String = null;
    public var maxMPBoost_:String = null;
    public var attackBoost_:String = null;
    public var defenseBoost_:String = null;
    public var speedBoost_:String = null;
    public var vitalityBoost_:String = null;
    public var wisdomBoost_:String = null;
    public var dexterityBoost_:String = null;
    public var xpBoost_:int = 0;
    public var healthPotionCount_:int = 0;
    public var magicPotionCount_:int = 0;
    public var attackMax_:int = 0;
    public var defenseMax_:int = 0;
    public var speedMax_:int = 0;
    public var dexterityMax_:int = 0;
    public var vitalityMax_:int = 0;
    public var wisdomMax_:int = 0;
    public var maxHPMax_:int = 0;
    public var maxMPMax_:int = 0;
    public var hasBackpack_:Boolean = false;
    public var accountType_:int = 0;
    public var admin_:Boolean = false;
    public var starred_:Boolean = false;
    public var ignored_:Boolean = false;
    public var distSqFromThisPlayer_:Number = 0;
    protected var rotate_:Number = 0;
    protected var relMoveVec_:Point = null;
    protected var moveMultiplier_:Number = 1;
    public var attackPeriod_:Number = 0;
    public var attackAmount_:int = 0;
    public var isDazed_:Boolean = false;
    public var isBerserk_:Boolean = false;
    public var minAttackFrequency_:Number = 0;
    public var maxAttackFrequency_:Number = 0;
    public var weaponRateOfFire_:Number = 0;
    public var nextAltAttack_:int = 0;
    public var nextTeleportAt_:int = 0;
    public var dropBoost:int = 0;
    public var tierBoost:int = 0;
    protected var healingEffect_:HealingEffect = null;
    protected var nearestMerchant_:Merchant = null;
    public var isDefaultAnimatedChar:Boolean = true;
    public var projectileIdSetOverrideNew:String = """";
    public var projectileIdSetOverrideOld:String = """";
    private var addTextLine:AddTextLineSignal;
    private var factory:CharacterFactory;
    private var ip_:IntPoint;
    private var breathBackFill_:GraphicsSolidFill = null;
    private var breathBackPath_:GraphicsPath = null;
    private var breathFill_:GraphicsSolidFill = null;
    private var breathPath_:GraphicsPath = null;
    private var hallucinatingMaskedImage_:MaskedImage = null;
    private var slideVec_:Vector3D;

    public function Player(_arg1:XML) {
        this.minAttackFrequency_ = 0.0015;
        this.maxAttackFrequency_ = 0.008;
        this.ip_ = new IntPoint();
        var _local2:Injector = StaticInjectorContext.getInjector();
        this.addTextLine = _local2.getInstance(AddTextLineSignal);
        this.factory = _local2.getInstance(CharacterFactory);
        super(_arg1);
        this.attackMax_ = int(_arg1.Attack.@max);
        this.defenseMax_ = int(_arg1.Defense.@max);
        this.speedMax_ = int(_arg1.Speed.@max);
        this.dexterityMax_ = int(_arg1.Dexterity.@max);
        this.vitalityMax_ = int(_arg1.HpRegen.@max);
        this.wisdomMax_ = int(_arg1.MpRegen.@max);
        this.maxHPMax_ = int(_arg1.MaxHitPoints.@max);
        this.maxMPMax_ = int(_arg1.MaxMagicPoints.@max);
        texturingCache_ = new Dictionary();
        this.slideVec_ = new Vector3D();
    }

    public static function fromPlayerXML(name:String, playerXML:XML):Player {
        var _local3:int = int(playerXML.ObjectType);
        var _local4:XML = ObjectLibrary.xmlLibrary_[_local3];
        var _local5:Player = new Player(_local4);
        _local5.name_ = name;
        _local5.level_ = int(playerXML.Level);
        _local5.exp_ = Number(playerXML.Exp);
        _local5.equipment_ = ConversionUtil.toIntVector(playerXML.Equipment);
        _local5.calculateStatBoosts();
        _local5.lockedSlot = new Vector.<int>(_local5.equipment_.length);
        _local5.maxHP_ = (Parameters.parse(_local5.maxHPBoost_) + int(playerXML.MaxHitPoints));
        _local5.hp_ = int(playerXML.HitPoints);
        _local5.maxMP_ = (Parameters.parse(_local5.maxMPBoost_) + int(playerXML.MaxMagicPoints));
        _local5.mp_ = int(playerXML.MagicPoints);
        _local5.attack_ = (Parameters.parse(_local5.attackBoost_) + int(playerXML.Attack)).toString();
        _local5.defense_ = (Parameters.parse(_local5.defenseBoost_) + int(playerXML.Defense)).toString();
        _local5.speed_ = (Parameters.parse(_local5.speedBoost_) + int(playerXML.Speed)).toString();
        _local5.dexterity_ = (Parameters.parse(_local5.vitalityBoost_) + int(playerXML.Dexterity)).toString();
        _local5.vitality_ = (Parameters.parse(_local5.wisdomBoost_) + int(playerXML.HpRegen)).toString();
        _local5.wisdom_ = (Parameters.parse(_local5.dexterityBoost_) + int(playerXML.MpRegen)).toString();
        _local5.tex1Id_ = int(playerXML.Tex1);
        _local5.tex2Id_ = int(playerXML.Tex2);
        _local5.hasBackpack_ = int(playerXML.HasBackpack) != 0;
        return (_local5);
    }

    public function calculateStatBoosts():void {
        var _local2:int;
        var _local3:XML;
        var _local4:XML;
        var _local5:int;
        var _local6:int;
        this.maxHPBoost_ = ""0"";
        this.maxMPBoost_ = ""0"";
        this.attackBoost_ = ""0"";
        this.defenseBoost_ = ""0"";
        this.speedBoost_ = ""0"";
        this.vitalityBoost_ = ""0"";
        this.wisdomBoost_ = ""0"";
        this.dexterityBoost_ = ""0"";
        var _local1:uint;
        while (_local1 < GeneralConstants.NUM_EQUIPMENT_SLOTS) {
            if (((equipment_) && ((equipment_.length > _local1)))) {
                _local2 = equipment_[_local1];
                if (_local2 != -1) {
                    _local3 = ObjectLibrary.xmlLibrary_[_local2];
                    if (((!((_local3 == null))) && (_local3.hasOwnProperty(""ActivateOnEquip"")))) {
                        for each (_local4 in _local3.ActivateOnEquip) {
                            if (_local4.toString() == ""IncrementStat"") {
                                _local5 = int(_local4.@stat);
                                _local6 = int(_local4.@amount);
                                switch (_local5) {
                                    case StatData.MAX_HP_STAT:
                                        this.maxHPBoost_ = (this.maxHPBoost_ + _local6);
                                        break;
                                    case StatData.MAX_MP_STAT:
                                        this.maxMPBoost_ = (this.maxMPBoost_ + _local6);
                                        break;
                                    case StatData.ATTACK_STAT:
                                        this.attackBoost_ = (Parameters.parse(this.attackBoost_) + _local6).toString();
                                        break;
                                    case StatData.DEFENSE_STAT:
                                        this.defenseBoost_ = (Parameters.parse(this.defenseBoost_) + _local6).toString();
                                        break;
                                    case StatData.SPEED_STAT:
                                        this.speedBoost_ = (Parameters.parse(this.speedBoost_) + _local6).toString();
                                        break;
                                    case StatData.VITALITY_STAT:
                                        this.vitalityBoost_ = (Parameters.parse(this.vitalityBoost_) + _local6).toString();
                                        break;
                                    case StatData.WISDOM_STAT:
                                        this.wisdomBoost_ = (Parameters.parse(this.wisdomBoost_) + _local6).toString();
                                        break;
                                    case StatData.DEXTERITY_STAT:
                                        this.dexterityBoost_ = (Parameters.parse(this.dexterityBoost_) + _local6).toString();
                                        break;
                                }
                            }
                        }
                    }
                }
            }
            _local1++;
        }
    }

    public function setRelativeMovement(_arg1:Number, _arg2:Number, _arg3:Number):void {
        var _local4:Number;
        if (this.relMoveVec_ == null) {
            this.relMoveVec_ = new Point();
        }
        this.rotate_ = _arg1;
        this.relMoveVec_.x = _arg2;
        this.relMoveVec_.y = _arg3;
        if (isConfused()) {
            _local4 = this.relMoveVec_.x;
            this.relMoveVec_.x = -(this.relMoveVec_.y);
            this.relMoveVec_.y = -(_local4);
            this.rotate_ = -(this.rotate_);
        }
    }

    public function setCredits(_arg1:int):void {
        this.credits_ = _arg1;
    }

    public function setTokens(_arg1:int):void {
        this.tokens_ = _arg1;
    }

    public function setGuildName(_arg1:String):void {
        var _local3:GameObject;
        var _local4:Player;
        var _local5:Boolean;
        this.guildName_ = _arg1;
        var _local2:Player = map_.player_;
        if (_local2 == this) {
            for each (_local3 in map_.goDict_) {
                _local4 = (_local3 as Player);
                if (((!((_local4 == null))) && (!((_local4 == this))))) {
                    _local4.setGuildName(_local4.guildName_);
                }
            }
        }
        else {
            _local5 = ((((((!((_local2 == null))) && (!((_local2.guildName_ == null))))) && (!((_local2.guildName_ == """"))))) && ((_local2.guildName_ == this.guildName_)));
            if (_local5 != this.isFellowGuild_) {
                this.isFellowGuild_ = _local5;
                nameBitmapData_ = null;
            }
        }
    }

    public function isTeleportEligible(_arg1:Player):Boolean {
        return (!(((_arg1.isPaused()) || (_arg1.isInvisible()))));
    }

    public function msUtilTeleport():int {
        var _local1:int = getTimer();
        return (Math.max(0, (this.nextTeleportAt_ - _local1)));
    }

    public function teleportTo(_arg1:Player):Boolean {
        if (isPaused()) {
            this.addTextLine.dispatch(this.makeErrorMessage(TextKey.PLAYER_NOTELEPORTWHILEPAUSED));
            return (false);
        }
        var _local2:int = this.msUtilTeleport();
        if (_local2 > 0) {
            this.addTextLine.dispatch(this.makeErrorMessage(TextKey.PLAYER_TELEPORT_COOLDOWN, {""seconds"": int(((_local2 / 1000) + 1))}));
            return (false);
        }
        if (!this.isTeleportEligible(_arg1)) {
            if (_arg1.isInvisible()) {
                this.addTextLine.dispatch(this.makeErrorMessage(TextKey.TELEPORT_INVISIBLE_PLAYER, {""player"": _arg1.name_}));
            }
            else {
                this.addTextLine.dispatch(this.makeErrorMessage(TextKey.PLAYER_TELEPORT_TO_PLAYER, {""player"": _arg1.name_}));
            }
            return (false);
        }
        map_.gs_.gsc_.playerText(""/teleport "" + _arg1.name_);
        this.nextTeleportAt_ = (getTimer() + MS_BETWEEN_TELEPORT);
        return (true);
    }

    private function makeErrorMessage(_arg1:String, _arg2:Object = null):ChatMessage {
        return (ChatMessage.make(Parameters.ERROR_CHAT_NAME, _arg1, -1, -1, """", false, _arg2));
    }

    public function levelUpEffect(_arg1:String, _arg2:Boolean = true):void {
        if (_arg2) {
            this.levelUpParticleEffect();
        }
        var _local3:QueuedStatusText = new QueuedStatusText(this, new LineBuilder().setParams(_arg1), 0xFF00, 2000);
        map_.mapOverlay_.addQueuedText(_local3);
    }

    public function handleLevelUp(_arg1:Boolean):void {
        SoundEffectLibrary.play(""level_up"");
        if (_arg1) {
            this.levelUpEffect(TextKey.PLAYER_NEWCLASSUNLOCKED, false);
            this.levelUpEffect(TextKey.PLAYER_LEVELUP);
        }
        else {
            this.levelUpEffect(TextKey.PLAYER_LEVELUP);
        }
    }

    public function levelUpParticleEffect(_arg1:uint = 0xFF00FF00):void {
        map_.addObj(new LevelUpEffect(this, _arg1, 20), x_, y_);
    }

    public function handleExpUp(_arg1:Number):void {
        var _local2:CharacterStatusText = new CharacterStatusText(this, 0xFFFFFF, 1000);
        _local2.setStringBuilder(new LineBuilder().setParams(TextKey.PLAYER_EXP, {""exp"": _arg1}));
        map_.mapOverlay_.addStatusText(_local2);
    }

    private function getNearbyMerchant():Merchant {
        var _local3:Point;
        var _local4:Merchant;
        var _local1:int = ((((x_ - int(x_))) > 0.5) ? 1 : -1);
        var _local2:int = ((((y_ - int(y_))) > 0.5) ? 1 : -1);
        for each (_local3 in NEARBY) {
            this.ip_.x_ = (x_ + (_local1 * _local3.x));
            this.ip_.y_ = (y_ + (_local2 * _local3.y));
            _local4 = map_.merchLookup_[this.ip_];
            if (_local4 != null) {
                return ((((PointUtil.distanceSquaredXY(_local4.x_, _local4.y_, x_, y_) < 1)) ? _local4 : null));
            }
        }
        return (null);
    }

    public function walkTo(_arg1:Number, _arg2:Number):Boolean {
        this.modifyMove(_arg1, _arg2, newP);
        return (this.moveTo(newP.x, newP.y));
    }

    override public function moveTo(_arg1:Number, _arg2:Number):Boolean {
        var _local3:Boolean = super.moveTo(_arg1, _arg2);
        if (map_.gs_.evalIsNotInCombatMapArea()) {
            this.nearestMerchant_ = this.getNearbyMerchant();
        }
        return (_local3);
    }

    public function modifyMove(_arg1:Number, _arg2:Number, _arg3:Point):void {
        if (((isParalyzed()) || (isPetrified()))) {
            _arg3.x = x_;
            _arg3.y = y_;
            return;
        }
        var _local4:Number = (_arg1 - x_);
        var _local5:Number = (_arg2 - y_);
        if ((((((((_local4 < MOVE_THRESHOLD)) && ((_local4 > -(MOVE_THRESHOLD))))) && ((_local5 < MOVE_THRESHOLD)))) && ((_local5 > -(MOVE_THRESHOLD))))) {
            this.modifyStep(_arg1, _arg2, _arg3);
            return;
        }
        var _local6:Number = (MOVE_THRESHOLD / Math.max(Math.abs(_local4), Math.abs(_local5)));
        var _local7:Number = 0;
        _arg3.x = x_;
        _arg3.y = y_;
        var _local8:Boolean;
        while (!(_local8)) {
            if ((_local7 + _local6) >= 1) {
                _local6 = (1 - _local7);
                _local8 = true;
            }
            this.modifyStep((_arg3.x + (_local4 * _local6)), (_arg3.y + (_local5 * _local6)), _arg3);
            _local7 = (_local7 + _local6);
        }
    }

    public function modifyStep(_arg1:Number, _arg2:Number, _arg3:Point):void {
        var _local6:Number;
        var _local7:Number;
        var _local4:Boolean = ((((((x_ % 0.5) == 0)) && (!((_arg1 == x_))))) || (!((int((x_ / 0.5)) == int((_arg1 / 0.5))))));
        var _local5:Boolean = ((((((y_ % 0.5) == 0)) && (!((_arg2 == y_))))) || (!((int((y_ / 0.5)) == int((_arg2 / 0.5))))));
        if (((((!(_local4)) && (!(_local5)))) || (this.isValidPosition(_arg1, _arg2)))) {
            _arg3.x = _arg1;
            _arg3.y = _arg2;
            return;
        }
        if (_local4) {
            _local6 = (((_arg1) > x_) ? (int((_arg1 * 2)) / 2) : (int((x_ * 2)) / 2));
            if (int(_local6) > int(x_)) {
                _local6 = (_local6 - 0.01);
            }
        }
        if (_local5) {
            _local7 = (((_arg2) > y_) ? (int((_arg2 * 2)) / 2) : (int((y_ * 2)) / 2));
            if (int(_local7) > int(y_)) {
                _local7 = (_local7 - 0.01);
            }
        }
        if (!_local4) {
            _arg3.x = _arg1;
            _arg3.y = _local7;
            if (((!((square_ == null))) && (!((square_.props_.slideAmount_ == 0))))) {
                this.resetMoveVector(false);
            }
            return;
        }
        if (!_local5) {
            _arg3.x = _local6;
            _arg3.y = _arg2;
            if (((!((square_ == null))) && (!((square_.props_.slideAmount_ == 0))))) {
                this.resetMoveVector(true);
            }
            return;
        }
        var _local8:Number = (((_arg1) > x_) ? (_arg1 - _local6) : (_local6 - _arg1));
        var _local9:Number = (((_arg2) > y_) ? (_arg2 - _local7) : (_local7 - _arg2));
        if (_local8 > _local9) {
            if (this.isValidPosition(_arg1, _local7)) {
                _arg3.x = _arg1;
                _arg3.y = _local7;
                return;
            }
            if (this.isValidPosition(_local6, _arg2)) {
                _arg3.x = _local6;
                _arg3.y = _arg2;
                return;
            }
        }
        else {
            if (this.isValidPosition(_local6, _arg2)) {
                _arg3.x = _local6;
                _arg3.y = _arg2;
                return;
            }
            if (this.isValidPosition(_arg1, _local7)) {
                _arg3.x = _arg1;
                _arg3.y = _local7;
                return;
            }
        }
        _arg3.x = _local6;
        _arg3.y = _local7;
    }

    private function resetMoveVector(_arg1:Boolean):void {
        moveVec_.scaleBy(-0.5);
        if (_arg1) {
            moveVec_.y = (moveVec_.y * -1);
        }
        else {
            moveVec_.x = (moveVec_.x * -1);
        }
    }

    public function isValidPosition(_arg1:Number, _arg2:Number):Boolean {
        var _local3:Square = map_.getSquare(_arg1, _arg2);
        if (((!((square_ == _local3))) && ((((_local3 == null)) || (!(_local3.isWalkable())))))) {
            return (false);
        }
        var _local4:Number = (_arg1 - int(_arg1));
        var _local5:Number = (_arg2 - int(_arg2));
        if (_local4 < 0.5) {
            if (this.isFullOccupy((_arg1 - 1), _arg2)) {
                return (false);
            }
            if (_local5 < 0.5) {
                if (((this.isFullOccupy(_arg1, (_arg2 - 1))) || (this.isFullOccupy((_arg1 - 1), (_arg2 - 1))))) {
                    return (false);
                }
            }
            else {
                if (_local5 > 0.5) {
                    if (((this.isFullOccupy(_arg1, (_arg2 + 1))) || (this.isFullOccupy((_arg1 - 1), (_arg2 + 1))))) {
                        return (false);
                    }
                }
            }
        }
        else {
            if (_local4 > 0.5) {
                if (this.isFullOccupy((_arg1 + 1), _arg2)) {
                    return (false);
                }
                if (_local5 < 0.5) {
                    if (((this.isFullOccupy(_arg1, (_arg2 - 1))) || (this.isFullOccupy((_arg1 + 1), (_arg2 - 1))))) {
                        return (false);
                    }
                }
                else {
                    if (_local5 > 0.5) {
                        if (((this.isFullOccupy(_arg1, (_arg2 + 1))) || (this.isFullOccupy((_arg1 + 1), (_arg2 + 1))))) {
                            return (false);
                        }
                    }
                }
            }
            else {
                if (_local5 < 0.5) {
                    if (this.isFullOccupy(_arg1, (_arg2 - 1))) {
                        return (false);
                    }
                }
                else {
                    if (_local5 > 0.5) {
                        if (this.isFullOccupy(_arg1, (_arg2 + 1))) {
                            return (false);
                        }
                    }
                }
            }
        }
        return (true);
    }

    public function isFullOccupy(_arg1:Number, _arg2:Number):Boolean {
        var _local3:Square = map_.lookupSquare(_arg1, _arg2);
        return ((((((_local3 == null)) || ((_local3.tileType_ == 0xFF)))) || (((!((_local3.obj_ == null))) && (_local3.obj_.props_.fullOccupy_)))));
    }

    override public function update(currentTime:int, deltaMS:int):Boolean {
        if (this.tierBoost && !isPaused()) {
            this.tierBoost = this.tierBoost - deltaMS;
            if (this.tierBoost < 0) {
                this.tierBoost = 0;
            }
        }
        if (this.dropBoost && !isPaused()) {
            this.dropBoost = this.dropBoost - deltaMS;
            if (this.dropBoost < 0) {
                this.dropBoost = 0;
            }
        }
        if (this.xpTimer && !isPaused()) {
            this.xpTimer = this.xpTimer - deltaMS;
            if (this.xpTimer < 0) {
                this.xpTimer = 0;
            }
        }

        if (isHealing() && !isPaused()) {
            if (this.healingEffect_ == null) {
                this.healingEffect_ = new HealingEffect(this);
                map_.addObj(this.healingEffect_, x_, y_);
            }
        }
        else {
            if (this.healingEffect_ != null) {
                map_.removeObj(this.healingEffect_.objectId_);
                this.healingEffect_ = null;
            }
        }

        var angle:Number = Parameters.data_.cameraAngle;
        if (this.rotate_ != 0) {
            angle = angle + deltaMS * Parameters.PLAYER_ROTATE_SPEED * this.rotate_;
            Parameters.data_.cameraAngle = angle;
        }

        if (map_.player_ == this && isPaused()) {
            return true;
        }

        if (this.relMoveVec_ != null) {
            if (this.relMoveVec_.x != 0 || this.relMoveVec_.y != 0) {
                var mvSpd:Number = this.getMoveSpeed();
                var mvAngle:Number = Math.atan2(this.relMoveVec_.y, this.relMoveVec_.x);
                if (square_.props_.slideAmount_ > 0) {
                    slideVec_.x = mvSpd * Math.cos(angle + mvAngle);
                    slideVec_.y = mvSpd * Math.sin(angle + mvAngle);
                    slideVec_.z = 0;
                    moveVec_.scaleBy(square_.props_.slideAmount_);
                    if (moveVec_.length < slideVec_.length) {
                        slideVec_.scaleBy(1 - square_.props_.slideAmount_);
                        moveVec_ = moveVec_.add(slideVec_);
                    }
                }
                else {
                    moveVec_.x = mvSpd * Math.cos(angle + mvAngle);
                    moveVec_.y = mvSpd * Math.sin(angle + mvAngle);
                }
            }
            else {
                if (moveVec_.length > 0.00012 && square_.props_.slideAmount_ > 0) {
                    moveVec_.scaleBy(square_.props_.slideAmount_);
                }
                else {
                    moveVec_.x = 0;
                    moveVec_.y = 0;
                }
            }
            if (square_ != null && square_.props_.push_) {
                moveVec_.x = moveVec_.x - square_.props_.animate_.dx_ / 1000;
                moveVec_.y = moveVec_.y - square_.props_.animate_.dy_ / 1000;
            }
            this.walkTo(x_ + deltaMS * moveVec_.x, y_ + deltaMS * moveVec_.y);
        }
        else {
            if (!super.update(currentTime, deltaMS)) {
                return false;
            }
        }
        if (map_.player_ == this &&
                square_.props_.maxDamage_ > 0 &&
                (square_.lastDamage_ + 500) < currentTime &&
                !isInvincible() &&
                (square_.obj_ == null || !square_.obj_.props_.protectFromGroundDamage_)) {
            var dmg:int = map_.gs_.gsc_.getNextDamage(square_.props_.minDamage_, square_.props_.maxDamage_);
            var conditionEffects:Vector.<uint> = new Vector.<uint>();
            conditionEffects.push(ConditionEffect.GROUND_DAMAGE);
            damage(-1, dmg, conditionEffects, hp_ <= dmg, null);
            map_.gs_.gsc_.groundDamage(currentTime, x_, y_);
            square_.lastDamage_ = currentTime;
        }
        return true;
    }

    public function onMove():void {
        if (map_ == null) {
            return;
        }
        var _local1:Square = map_.getSquare(x_, y_);
        if (_local1.props_.sinking_) {
            sinkLevel_ = Math.min((sinkLevel_ + 1), Parameters.MAX_SINK_LEVEL);
            this.moveMultiplier_ = (0.1 + ((1 - (sinkLevel_ / Parameters.MAX_SINK_LEVEL)) * (_local1.props_.speed_ - 0.1)));
        }
        else {
            sinkLevel_ = 0;
            this.moveMultiplier_ = _local1.props_.speed_;
        }
    }

    override protected function makeNameBitmapData():BitmapData {
        var _local1:StringBuilder = new StaticStringBuilder(name_);
        var _local2:BitmapTextFactory = StaticInjectorContext.getInjector().getInstance(BitmapTextFactory);
        var _local3:BitmapData = _local2.make(_local1, 16, this.getNameColor(), true, NAME_OFFSET_MATRIX, true);
        _local3.draw(FameUtil.numStarsToIcon(this.numStars_), RANK_OFFSET_MATRIX);
        return (_local3);
    }

    private function getNameColor():uint {
        if (this.isFellowGuild_) {
            return (Parameters.FELLOW_GUILD_COLOR);
        }
        if (this.nameChosen_) {
            return (Parameters.NAME_CHOSEN_COLOR);
        }
        return (0xFFFFFF);
    }

    protected function drawBreathBar(_arg1:Vector.<IGraphicsData>, _arg2:int):void {
        var _local7:Number;
        var _local8:Number;
        if (this.breathPath_ == null) {
            this.breathBackFill_ = new GraphicsSolidFill();
            this.breathBackPath_ = new GraphicsPath(GraphicsUtil.QUAD_COMMANDS, new Vector.<Number>());
            this.breathFill_ = new GraphicsSolidFill(2542335);
            this.breathPath_ = new GraphicsPath(GraphicsUtil.QUAD_COMMANDS, new Vector.<Number>());
        }
        if (this.breath_ <= Parameters.BREATH_THRESH) {
            _local7 = ((Parameters.BREATH_THRESH - this.breath_) / Parameters.BREATH_THRESH);
            this.breathBackFill_.color = MoreColorUtil.lerpColor(0x545454, 0xFF0000, (Math.abs(Math.sin((_arg2 / 300))) * _local7));
        }
        else {
            this.breathBackFill_.color = 0x545454;
        }
        var _local3:int = 20;
        var _local4:int = 8;
        var _local5:int = 6;
        var _local6:Vector.<Number> = (this.breathBackPath_.data as Vector.<Number>);
        _local6.length = 0;
        _local6.push((posS_[0] - _local3), (posS_[1] + _local4), (posS_[0] + _local3), (posS_[1] + _local4), (posS_[0] + _local3), ((posS_[1] + _local4) + _local5), (posS_[0] - _local3), ((posS_[1] + _local4) + _local5));
        _arg1.push(this.breathBackFill_);
        _arg1.push(this.breathBackPath_);
        _arg1.push(GraphicsUtil.END_FILL);
        if (this.breath_ > 0) {
            _local8 = (((this.breath_ / 100) * 2) * _local3);
            this.breathPath_.data.length = 0;
            _local6 = (this.breathPath_.data as Vector.<Number>);
            _local6.length = 0;
            _local6.push((posS_[0] - _local3), (posS_[1] + _local4), ((posS_[0] - _local3) + _local8), (posS_[1] + _local4), ((posS_[0] - _local3) + _local8), ((posS_[1] + _local4) + _local5), (posS_[0] - _local3), ((posS_[1] + _local4) + _local5));
            _arg1.push(this.breathFill_);
            _arg1.push(this.breathPath_);
            _arg1.push(GraphicsUtil.END_FILL);
        }
        GraphicsFillExtra.setSoftwareDrawSolid(this.breathFill_, true);
        GraphicsFillExtra.setSoftwareDrawSolid(this.breathBackFill_, true);
    }

    override public function draw(_arg1:Vector.<IGraphicsData>, _arg2:Camera, _arg3:int):void {
        if (this != map_.player_) {
            if(Parameters.data_.hidePlayers){
                return;
            }
            if (!Parameters.screenShotMode_) {
                drawName(_arg1, _arg2);
            }
        }
        else {
            if (this.breath_ >= 0) {
                this.drawBreathBar(_arg1, _arg3);
            }
        }
        super.draw(_arg1, _arg2, _arg3);
    }

    private function getMoveSpeed():Number {
        if (isSlowed()) {
            return ((MIN_MOVE_SPEED * this.moveMultiplier_));
        }
        var _local1:Number = (MIN_MOVE_SPEED + ((Parameters.parse(this.speed_) / 75) * (MAX_MOVE_SPEED - MIN_MOVE_SPEED)));
        if (((isSpeedy()) || (isNinjaSpeedy()))) {
            _local1 = (_local1 * 1.5);
        }
        return ((_local1 * this.moveMultiplier_));
    }

    public function attackFrequency():Number {
        this.isDazed_ = isDazed();
        this.isBerserk_ = isBerserk();

        if (this.isDazed_)
            return this.minAttackFrequency_;

        var _rateOfFire:Number = this.minAttackFrequency_ + ((Parameters.parse(this.dexterity_) / 75) * (this.maxAttackFrequency_ - this.minAttackFrequency_));

        if (this.isBerserk_)
            _rateOfFire *= 1.5;

        return (_rateOfFire);
    }

    private function attackMultiplier():Number {
        if (isWeak()) {
            return (MIN_ATTACK_MULT);
        }
        var _local1:Number = (MIN_ATTACK_MULT + (((this.attackLevel_ + Parameters.parse(this.attackBoost_)) / 75) * (MAX_ATTACK_MULT - MIN_ATTACK_MULT)));
        if (isDamaging()) {
            _local1 = (_local1 * 1.5);
        }
        return (_local1);
    }

    private function makeSkinTexture():void {
        var _local1:MaskedImage = this.skin.imageFromAngle(0, AnimatedChar.STAND, 0);
        animatedChar_ = this.skin;
        texture_ = _local1.image_;
        mask_ = _local1.mask_;
        this.isDefaultAnimatedChar = true;
    }

    private function setToRandomAnimatedCharacter():void {
        var _local1:Vector.<XML> = ObjectLibrary.hexTransforms_;
        var _local2:uint = Math.floor((Math.random() * _local1.length));
        var _local3:int = _local1[_local2].@type;
        var _local4:TextureData = ObjectLibrary.typeToTextureData_[_local3];
        texture_ = _local4.texture_;
        mask_ = _local4.mask_;
        animatedChar_ = _local4.animatedChar_;
        this.isDefaultAnimatedChar = false;
    }

    override protected function getTexture(camera:Camera, currentTime:int):BitmapData {
        var pos:Number = 0;
        var action:int = AnimatedChar.STAND;

        if (this.isShooting || currentTime < (attackStart_ + this.attackPeriod_)) {
            facing_ = attackAngle_;
            pos = ((currentTime - attackStart_) % this.attackPeriod_) / this.attackPeriod_;
            action = AnimatedChar.ATTACK;
        }
        else {
            if (moveVec_.x != 0 || moveVec_.y != 0) {
                var movPeriod:int = 3.5 / this.getMoveSpeed();
                if (moveVec_.y != 0 || moveVec_.x != 0) {
                    facing_ = Math.atan2(moveVec_.y, moveVec_.x);
                }
                pos = (currentTime % movPeriod) / movPeriod;
                action = AnimatedChar.WALK;
            }
        }

        if (this.isHexed()) {
            this.isDefaultAnimatedChar && this.setToRandomAnimatedCharacter();
        }
        else {
            if (!this.isDefaultAnimatedChar) {
                this.makeSkinTexture();
            }
        }

        var maskImg:MaskedImage;
        if (camera.isHallucinating_) {
            maskImg = getHallucinatingMaskedImage();
        }
        else {
            maskImg = animatedChar_.imageFromFacing(facing_, camera, action, pos);
        }

        var tex1Id:int = tex1Id_;
        var tex2Id:int = tex2Id_;
        var tex:BitmapData;
        if (this.nearestMerchant_) {
            var merchDict:Dictionary = texturingCache_[this.nearestMerchant_];
            if (merchDict == null) {
                texturingCache_[this.nearestMerchant_] = new Dictionary();
            }
            else {
                tex = merchDict[maskImg];
            }
            tex1Id = this.nearestMerchant_.getTex1Id(tex1Id_);
            tex2Id = this.nearestMerchant_.getTex2Id(tex2Id_);
        }
        else {
            tex = texturingCache_[maskImg];
        }
        if (tex == null) {
            tex = TextureRedrawer.resize(maskImg.image_, maskImg.mask_, size_, false, tex1Id, tex2Id);
            if (this.nearestMerchant_ != null) {
                texturingCache_[this.nearestMerchant_][maskImg] = tex;
            }
            else {
                texturingCache_[maskImg] = tex;
            }
        }

        if (hp_ < maxHP_ * 0.2) {
            var intensity:Number = int(Math.abs(Math.sin(currentTime / 200)) * 10) / 10;
            var ct:ColorTransform = lowHealthCT[intensity];
            if (ct == null) {
                ct = new ColorTransform(1, 1, 1, 1,
                        intensity * LOW_HEALTH_CT_OFFSET,
                        -intensity * LOW_HEALTH_CT_OFFSET,
                        -intensity * LOW_HEALTH_CT_OFFSET);
                lowHealthCT[intensity] = ct;
            }
            tex = CachingColorTransformer.transformBitmapData(tex, ct);
        }

        var plrTex:BitmapData = texturingCache_[tex];
        if (plrTex == null) {
            plrTex = GlowRedrawer.outlineGlowPlayer(tex, this.glowColor_);
            texturingCache_[tex] = plrTex;
        }
        if (isPaused() || isStasis() || isPetrified()) {
            plrTex = CachingColorTransformer.filterBitmapData(plrTex, PAUSED_FILTER);
        }
        else {
            if (isInvisible()) {
                plrTex = CachingColorTransformer.alphaBitmapData(plrTex, 40);
            }
        }
        return plrTex;
    }

    private function getHallucinatingMaskedImage():MaskedImage {
        if (hallucinatingMaskedImage_ == null) {
            hallucinatingMaskedImage_ = new MaskedImage(getHallucinatingTexture(), null);
        }
        return hallucinatingMaskedImage_;
    }

    override public function getPortrait():BitmapData {
        var _local1:MaskedImage;
        var _local2:int;
        if (portrait_ == null) {
            _local1 = animatedChar_.imageFromDir(AnimatedChar.RIGHT, AnimatedChar.STAND, 0);
            _local2 = ((4 / _local1.image_.width) * 100);
            portrait_ = TextureRedrawer.resize(_local1.image_, _local1.mask_, _local2, true, tex1Id_, tex2Id_);
            portrait_ = GlowRedrawer.outlineGlow(portrait_, 0);
        }
        return (portrait_);
    }

    public function useAltWeapon(_arg1:Number, _arg2:Number, _arg3:int):Boolean {
        var _local7:XML;
        var _local8:int;
        var _local9:Number;
        var _local10:int;
        var _local11:int;
        var _local12:Boolean;
        if ((((map_ == null)) || (isPaused()))) {
            return (false);
        }
        var _local4:int = equipment_[1];
        if (_local4 == -1) {
            return (false);
        }
        var _local5:XML = ObjectLibrary.xmlLibrary_[_local4];
        if ((((_local5 == null)) || (!(_local5.hasOwnProperty(""Usable""))))) {
            return (false);
        }
        var _local6:Point = map_.pSTopW(_arg1, _arg2);
        if (_local6 == null) {
            SoundEffectLibrary.play(""error"");
            return (false);
        }
        for each (_local7 in _local5.Activate) {
            if (_local7.toString() == ActivationType.TELEPORT) {
                if (!this.isValidPosition(_local6.x, _local6.y)) {
                    SoundEffectLibrary.play(""error"");
                    return (false);
                }
            }
        }
        _local8 = getTimer();
        if (_arg3 == UseType.START_USE) {
            if (_local8 < this.nextAltAttack_) {
                SoundEffectLibrary.play(""error"");
                return (false);
            }
            _local10 = int(_local5.MpCost);
            if (_local10 > this.mp_) {
                SoundEffectLibrary.play(""no_mana"");
                return (false);
            }
            _local11 = 2000;
            if (_local5.hasOwnProperty(TextKey.COOLDOWN)) {
                _local11 = (Number(_local5.Cooldown) * NumberKey.COOLDOWNVALUE);
            }
            this.nextAltAttack_ = (_local8 + _local11);

            map_.gs_.gsc_.useItem(_local8, objectId_, 1, _local4, _local6.x, _local6.y, _arg3, isTrading);
        }
        else {
            if (_local5.hasOwnProperty(""MultiPhase"")) {
                map_.gs_.gsc_.useItem(_local8, objectId_, 1, _local4, _local6.x, _local6.y, _arg3, isTrading);

                _local10 = int(_local5.MpEndCost);
                if (_local10 <= this.mp_) {
                    _local9 = Math.atan2(_arg2, _arg1);
                    this.doShoot(_local4, _local5, (Parameters.data_.cameraAngle + _local9), false, false);
                }
            }
        }
        return (true);
    }

    public function attemptAttackAngle(_arg1:Number):void {
        this.shoot((Parameters.data_.cameraAngle + _arg1));
    }

    override public function setAttack(_arg1:int, _arg2:Number):void {
        var _local3:XML = ObjectLibrary.xmlLibrary_[_arg1];
        if ((((_local3 == null)) || (!(_local3.hasOwnProperty(TextKey.RATEOFFIRE))))) {
            return;
        }
        var _local4:Number = Number(_local3.RateOfFire);
        this.attackPeriod_ = ((NumberKey.RATEOFFIREVALUE / this.attackFrequency()) * (NumberKey.RATEOFFIREVALUE / _local4));
        super.setAttack(_arg1, _arg2);
    }

    private function shoot(angle:Number):void {
        if (map_ == null || isStunned() || isPaused() || isPetrified())
            return;

        var weapType:int = this.equipment_[0];

        if (weapType == -1)
            return;

        var weapon:XML = ObjectLibrary.xmlLibrary_[weapType];
        var curTime:int = getTimer();

        this.weaponRateOfFire_ = Number(weapon.RateOfFire);
        this.attackPeriod_ = (NumberKey.RATEOFFIREVALUE / this.attackFrequency()) * (NumberKey.RATEOFFIREVALUE / this.weaponRateOfFire_);

        if (curTime < this.attackStart_ + this.attackPeriod_)
            return;

        doneAction(map_.gs_, Tutorial.ATTACK_ACTION);

        this.attackAngle_ = angle;
        this.attackStart_ = curTime;
        this.doShoot(weapType, weapon, attackAngle_, true, false);
    }

    private function doShoot(weaponType:int, weaponXML:XML, attackAngle:Number, isShooting:Boolean, isAbility:Boolean):void {
        var _local11:uint;
        var _local12:Projectile;
        var _local13:int;
        var _local14:int;
        var _local15:Number;
        var _local16:int;
        var arcGap:Number = (weaponXML.hasOwnProperty(TextKey.ARCGAP) ? Number(weaponXML.ArcGap) : NumberKey.ARCGAPVALUE) * Trig.toRadians;
        var _local8:Number = (arcGap * (this.attackAmount_ - 1));
        var _local9:Number = (attackAngle - (_local8 / 2));
        this.isShooting = isShooting;
        this.attackAmount_ = weaponXML.hasOwnProperty(TextKey.NUMPROJECTILES) ? int(weaponXML.NumProjectiles) : NumberKey.NUMPROJECTILESVALUE;
        var _local10:int;
        while (_local10 < this.attackAmount_) {
            _local11 = getBulletId();
            _local12 = (FreeList.newObject(Projectile) as Projectile);
            if (((isShooting) && (!((this.projectileIdSetOverrideNew == """"))))) {
                _local12.reset(weaponType, 0, objectId_, _local11, _local9, this.attackStart_, this.projectileIdSetOverrideNew, this.projectileIdSetOverrideOld);
            }
            else {
                _local12.reset(weaponType, 0, objectId_, _local11, _local9, this.attackStart_);
            }
            _local13 = int(_local12.projProps_.minDamage_);
            _local14 = int(_local12.projProps_.maxDamage_);
            _local15 = ((isShooting) ? this.attackMultiplier() : 1);
            _local16 = (map_.gs_.gsc_.getNextDamage(_local13, _local14) * _local15);
            _local12.setDamage(_local16);
            if ((((_local10 == 0)) && (!((_local12.sound_ == null))))) {
                SoundEffectLibrary.play(_local12.sound_, 0.75, false);
            }
            map_.addObj(_local12, (x_ + (Math.cos(attackAngle) * 0.3)), (y_ + (Math.sin(attackAngle) * 0.3)));
            map_.gs_.gsc_.playerShoot(_local12, this.attackAmount_, this.isDazed_, this.isBerserk_, this.minAttackFrequency_, this.maxAttackFrequency_, this.weaponRateOfFire_, isAbility);
            _local9 = (_local9 + arcGap);
            _local10++;
        }
    }

    public function isHexed():Boolean {
        return (!(((condition_[ConditionEffect.CE_FIRST_BATCH] & ConditionEffect.HEXED_BIT) == 0)));
    }

    public function isInventoryFull():Boolean {
        if (equipment_ == null) {
            return (false);
        }
        var _local1:int = equipment_.length;
        var _local2:uint = 4;
        while (_local2 < _local1) {
            if (equipment_[_local2] <= 0) {
                return (false);
            }
            _local2++;
        }
        return (true);
    }

    public function nextAvailableInventorySlot():int {
        var _local1:int = ((this.hasBackpack_) ? equipment_.length : (equipment_.length - GeneralConstants.NUM_INVENTORY_SLOTS));
        var _local2:uint = 4;
        while (_local2 < _local1) {
            if (equipment_[_local2] <= 0) {
                return (_local2);
            }
            _local2++;
        }
        return (-1);
    }

    public function numberOfAvailableSlots():int {
        var _local1:int = ((this.hasBackpack_) ? equipment_.length : (equipment_.length - GeneralConstants.NUM_INVENTORY_SLOTS));
        var _local2:int;
        var _local3:uint = 4;
        while (_local3 < _local1) {
            if (equipment_[_local3] <= 0) {
                _local2++;
            }
            _local3++;
        }
        return (_local2);
    }

    public function swapInventoryIndex(_arg1:String):int {
        var _local2:int;
        var _local3:int;
        if (!this.hasBackpack_) {
            return (-1);
        }
        if (_arg1 == TabStripModel.BACKPACK) {
            _local2 = GeneralConstants.NUM_EQUIPMENT_SLOTS;
            _local3 = (GeneralConstants.NUM_EQUIPMENT_SLOTS + GeneralConstants.NUM_INVENTORY_SLOTS);
        }
        else {
            _local2 = (GeneralConstants.NUM_EQUIPMENT_SLOTS + GeneralConstants.NUM_INVENTORY_SLOTS);
            _local3 = equipment_.length;
        }
        var _local4:uint = _local2;
        while (_local4 < _local3) {
            if (equipment_[_local4] <= 0) {
                return (_local4);
            }
            _local4++;
        }
        return (-1);
    }

    public function getPotionCount(_arg1:int):int {
        switch (_arg1) {
            case PotionInventoryModel.HEALTH_POTION_ID:
                return (this.healthPotionCount_);
            case PotionInventoryModel.MAGIC_POTION_ID:
                return (this.magicPotionCount_);
        }
        return (0);
    }

    public function getTex1():int {
        return (tex1Id_);
    }

    public function getTex2():int {
        return (tex2Id_);
    }


}
}
",12139,False,2119.7887099100762,median
"#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <WebSocketsServer.h>
#include <Hash.h>

String CommOut=""""; String CommIn=""""; String lastComm = """";
int StepSpeed = 50; int lastSpeed = 50;
int SMov[32]={1440,1440,1440,0,1440,1440,1440,0,0,0,0,0,1440,1440,1440,0,1440,1440,1440,0,0,0,0,0,1440,1440,1440,0,1440,1440,1440,0};
int SAdj[32]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int StaBlink=0; int IntBlink=0;
int ClawPos=1500;

//SSID and Password to your ESP Access Point
const char* ssid = ""HexapodWifi"";
const char* password = ""12345678"";

static const char PROGMEM INDEX_HTML[] = R""rawliteral(
<!DOCTYPE html><html><head><meta name = ""viewport"" content = ""width = device-width, initial-scale = 1.0, maximum-scale = 1.0, user-scalable=0""><title>ESP8266 Spider Hexapod</title><style>""body { background-color: #808080; font-family: Arial, Helvetica, Sans-Serif; Color: #000000; }""
#JD {text-align: center;}#JD {text-align: center;font-family: ""Lucida Sans Unicode"", ""Lucida Grande"", sans-serif;font-size: 24px;}.foot {text-align: center;font-family: ""Comic Sans MS"", cursive;font-size: 9px;color: #F00;}
.button {border: none;color: white;padding: 20px;text-align: center;text-decoration: none;display: inline-block;font-size: 16px;margin: 4px 2px;cursor: pointer;border-radius: 12px;width: 100%;}.red {background-color: #F00;}.green {background-color: #090;}.yellow {background-color:#F90;}.blue {background-color:#03C;}</style>
<script>var websock;function start() {websock = new WebSocket('ws://' + window.location.hostname + ':81/');websock.onopen = function(evt) { console.log('websock open'); };websock.onclose = function(evt) { console.log('websock close'); };websock.onerror = function(evt) { console.log(evt); }; 
websock.onmessage = function(evt) {console.log(evt);var e = document.getElementById('ledstatus');if (evt.data === 'ledon') { e.style.color = 'red';}else if (evt.data === 'ledoff') {e.style.color = 'black';} else {console.log('unknown event');}};} function buttonclick(e) {websock.send(e.id);}</script>
</head><body onload=""javascript:start();"">&nbsp;<table width=""100%"" border=""1""><tr><td bgcolor=""#FFFF33"" id=""JD"">Quadruped Controller</td></tr></table>
<table width=""100"" height=""249"" border=""0"" align=""center"">
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 20"" type=""button"" onclick=""buttonclick(this);"" class=""button red"">Claw_Close</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 1 1"" type=""button"" onclick=""buttonclick(this);"" class=""button green"">Forward</button></label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 21""  type=""button"" onclick=""buttonclick(this);"" class=""button red"">Claw_Open</button> </label></form></td></tr>
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 3 1"" type=""button"" onclick=""buttonclick(this);"" class=""button green"">Turn_Left</button></label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 0 1""  type=""button"" onclick=""buttonclick(this);"" class=""button red"">Stop_all</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 4 1""  type=""button"" onclick=""buttonclick(this);"" class=""button green"">Turn_Right</button></label></form></td></tr>
<tr><td>&nbsp;</td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 2 1"" type=""button"" onclick=""buttonclick(this);"" class=""button green"">Backward</button></label></form></td><td>&nbsp;</td></tr>
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 5 3"" type=""button"" onclick=""buttonclick(this);"" class=""button yellow"">Shake </button></label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 8 5""  type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Head_up</button></label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 6 3""  type=""button"" onclick=""buttonclick(this);"" class=""button yellow"">Wave</button></label></form></td></tr>
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 16"" type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Twist_Left</button></label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 9 5""  type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Head_down</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 17""  type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Twist_Right</button> </label></form></td></tr>
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 11 5"" type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Body_left</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 13""  type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Body_higher</button></label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 10 5""  type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Body_right</button></label></form></td></tr>
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 12"" type=""button"" onclick=""buttonclick(this);"" class=""button yellow"">Service</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 14""  type=""button"" onclick=""buttonclick(this);"" class=""button blue"">Body_lower</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 15""  type=""button"" onclick=""buttonclick(this);"" class=""button yellow"">Reset_Pose</button> </label></form></td></tr>
<tr><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 0 0"" type=""button"" onclick=""buttonclick(this);"" class=""button yellow"">Walk</button> </label></form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action="""">&nbsp;</form></td><td align=""center"" valign=""middle""><form name=""form1"" method=""post"" action=""""><label><button id=""w 7 1""  type=""button"" onclick=""buttonclick(this);"" class=""button yellow"">Run</button> </label></form></td></tr>
</table><p class=""foot"">this application requires Mwilmar Quadruped platform.</p></body></html>
)rawliteral"";


WebSocketsServer webSocket = WebSocketsServer(81);
ESP8266WebServer server(80);

void setup() {
  pinMode(LED_BUILTIN, OUTPUT); 
  Serial.begin(115200);
  Serial.println ("">> Setup"");
  for(uint8_t t = 4;t > 0;t--) {
    Serial.flush();
    delay(1000);
  }
  delay(1000);
  WiFi.mode(WIFI_AP);           //Only Access point
  WiFi.softAP(ssid, password);  //Start HOTspot removing password will disable security
 
  IPAddress myIP = WiFi.softAPIP(); //Get IP address
  Serial.println("""");
  Serial.print(""Connected to "");
  Serial.println(ssid);
  Serial.print(""IP address: "");   
  Serial.println(myIP);

    server.on(""/"", [](){
    server.send(200, ""text/html"", INDEX_HTML);
    });
    
    server.begin();
    
    webSocket.begin();
    webSocket.onEvent(webSocketEvent);

}

void loop() {
   if (Serial.available() > 0){
      char c[] = {(char)Serial.read()};
      webSocket.broadcastTXT(c, sizeof(c));
   }
    
   IntBlink +=1;
   if (IntBlink >=5000){
      if (StaBlink ==0){
        digitalWrite(LED_BUILTIN, HIGH); 
        StaBlink=1;
      } else {
        digitalWrite(LED_BUILTIN, LOW); 
        StaBlink=0;
      }
    IntBlink =0;
   }
   webSocket.loop();
   server.handleClient();
   if (CommOut == ""w 0 1"") Move_STP(); //~~~~~~~~ Stop
   if (CommOut == ""w 1 1"") Move_FWD(); //~~~~~~~~ Forward
   if (CommOut == ""w 2 1"") Move_BWD(); //~~~~~~~~ backward
   if (CommOut == ""w 3 1"") Move_LFT(); //~~~~~~~~ turn left
   if (CommOut == ""w 4 1"") Move_RGT(); //~~~~~~~~ turn right
   //~~~~~~~~ shake hand
   if (CommOut == ""w 5 3""){
     lastSpeed = StepSpeed;StepSpeed = 300;
     Move_SHK();StepSpeed = lastSpeed;CommOut=lastComm;
   }
   //~~~~~~~~ waving
   if (CommOut == ""w 6 3""){
     lastSpeed = StepSpeed;StepSpeed = 300;
     Move_WAV();StepSpeed = lastSpeed;CommOut=lastComm;
   }
   //~~~~~~~~ pos initial
   if (CommOut == ""w 15"") {
    Pos_INT();CommOut=lastComm;
   }
   //~~~~~~~~ pos service
   if (CommOut == ""w 12"") {
    Pos_SRV();CommOut=lastComm;
   }
   //~~~~~~~~ adjust body left
   if (CommOut == ""w 11 5"") {
    Adj_LF();CommOut=lastComm;
   }
   //~~~~~~~~ adjust body right
   if (CommOut == ""w 10 5"") {
    Adj_RG();CommOut=lastComm;
   }
   //~~~~~~~~ adjust head up
   if (CommOut == ""w 8 5"") {
    Adj_HU();CommOut=lastComm;
   }
   //~~~~~~~~ adjust head down
   if (CommOut == ""w 9 5"") {
    Adj_HD();CommOut=lastComm;
   }
   //~~~~~~~~ adjust body higher
   if (CommOut == ""w 13"") {
    Adj_HG();CommOut=lastComm;
   }
   //~~~~~~~~ adjust body lower
   if (CommOut == ""w 14"") {
    Adj_LW();CommOut=lastComm;
   }
   //~~~~~~~~ adjust twist left
   if (CommOut == ""w 16"") {
    Adj_TL();CommOut=lastComm;
   }
   //~~~~~~~~ adjust twist right
   if (CommOut == ""w 17"") {
    Adj_TR();CommOut=lastComm;
   }
   //~~~~~~~~ adjust speed walk
   if (CommOut == ""w 0 0"") {
    StepSpeed = 300;CommOut=lastComm;
   }
   //~~~~~~~~ adjust speed run
   if (CommOut == ""w 7 1"") {
    StepSpeed = 50;CommOut=lastComm;
   }
   //~~~~~~~  claw close
   if (CommOut == ""w 20"") {
    ClwCls();CommOut=lastComm;
   }
   //~~~~~~~~~~~ claw open
   if (CommOut == ""w 21"") {
    ClwOpn();CommOut=lastComm;
   }
}

void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length)
{
  switch(type) {
    case WStype_DISCONNECTED:
      break;
    case WStype_CONNECTED:
      {
        IPAddress ip = webSocket.remoteIP(num);
      }
      break;
    case WStype_TEXT:
      lastComm = CommOut; CommOut = """";
      for(int i = 0;i < length;i++) CommOut += ((char) payload[i]);
      // send data to all connected clients
      webSocket.broadcastTXT(payload, length);
      break;
    case WStype_BIN:
      hexdump(payload, length);
      // echo data back to browser
      webSocket.sendBIN(num, payload, length);
      break;default:break;
  }
}

void Send_Comm() {
  String SendString;int i;
  for (i = 1;i < 32;i += 1) {
    if (SMov[i]>=600 and SMov[i]<=2280){
      SendString = SendString +""#"" +i +""P"" +String(SMov[i]);
    }
  }
  Serial.print (SendString +""T""+String(StepSpeed)+""D0\\r\\n"");wait_serial_return_ok();
}

void wait_serial_return_ok()
{  
 // int TimeOut=0; 
  int num=0; char c[16]; while(1)
  {
   // TimeOut +=1;
    while(Serial.available() > 0)
    {
      webSocket.loop();server.handleClient();
      c[num]=Serial.read();num++;
      if(num>=15) num=0;
    }
    if(c[num-2]=='O'&&c[num-1]=='K') break;
  //  if(TimeOut > 800000) break;
  }
}


//================================================================================= Servo Move =======================================================================
//~~~~~~~~ claw open
void ClwOpn(){
  ClawPos=1000;
  if (ClawPos <= 1000) ClawPos=1000;
  Serial.println(""#9P"" + String(ClawPos) + ""T50D0"");
  wait_serial_return_ok();
}
//~~~~~~~~~~claw close
void ClwCls(){
  ClawPos +=100;
  if (ClawPos >= 1600) ClawPos=1600;
  Serial.println(""#9P"" + String(ClawPos) + ""T50D0"");
  wait_serial_return_ok();
}
//~~~~~~~~ Service position
void Pos_SRV(){
  lastSpeed = StepSpeed;StepSpeed = 50;
  SMov[29]=SAdj[29]+1440;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1440;SMov[17]=SAdj[17]+1440;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1440;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1440;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1440;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1440;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1440;Send_Comm();
  StepSpeed = lastSpeed;
}
//~~~~~~~~ Initial position (adjust all init servo here)
void Pos_INT(){
  SAdj[29]=0;SAdj[30]=0;SAdj[31]=0;SAdj[17]=0;SAdj[18]=0;SAdj[19]=0;SAdj[1]=0;SAdj[2]=0;SAdj[3]=0;SAdj[5]=0;SAdj[6]=0;SAdj[7]=0;SAdj[13]=0;SAdj[14]=0;SAdj[15]=0;SAdj[25]=0;SAdj[26]=0;SAdj[27]=0;Send_Comm();
  Pos_SRV();
}
//~~~~~~~~ Stop motion
void Move_STP(){
  SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1440;Send_Comm();
}
//~~~~~~~~ Shake hand
void Move_SHK(){
  SMov[5]=SAdj[5]+1117;SMov[6]=SAdj[6]+2218;SMov[7]=SAdj[7]+1828;Send_Comm();
  SMov[7]=SAdj[7]+1246;Send_Comm();
  SMov[7]=SAdj[7]+1795;Send_Comm();
  SMov[7]=SAdj[7]+1182;Send_Comm();
  SMov[7]=SAdj[7]+1763;Send_Comm();
  SMov[7]=SAdj[7]+1117;Send_Comm();
  SMov[5]=SAdj[5]+1440;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;Send_Comm();
}
//~~~~~~~~ Waving hand
void Move_WAV(){
  SMov[5]=SAdj[5]+1058;SMov[6]=SAdj[6]+1975;SMov[7]=SAdj[7]+2280;Send_Comm();
  SMov[5]=SAdj[5]+1478;Send_Comm();
  SMov[5]=SAdj[5]+1096;Send_Comm();
  SMov[5]=SAdj[5]+1478;Send_Comm();
  SMov[5]=SAdj[5]+1096;Send_Comm();
  SMov[5]=SAdj[5]+1478;Send_Comm();
  SMov[5]=SAdj[5]+1440;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;Send_Comm();
}
//~~~~~~~~ adjust body higher
void Adj_HG(){
   SAdj[6]-=50;SAdj[7]+=25;SAdj[14]-=50;SAdj[15]+=25;SAdj[26]-=50;SAdj[27]+=25;SAdj[2]+=50;SAdj[3]-=25;SAdj[18]+=50;SAdj[19]-=25;SAdj[30]+=50;SAdj[31]-=25;
   Pos_SRV();
}
//~~~~~~~~ adjust body lower
void Adj_LW(){
  SAdj[6]+=50;SAdj[7]-=25;SAdj[14]+=50;SAdj[15]-=25;SAdj[26]+=50;SAdj[27]-=25;SAdj[2]-=50;SAdj[3]+=25;SAdj[18]-=50;SAdj[19]+=25;SAdj[30]-=50;SAdj[31]+=25;
  Pos_SRV();
}
//~~~~~~~~ adjust head up
void Adj_HU(){
   SAdj[6]-=50;SAdj[7]+=25;SAdj[26]+=50;SAdj[27]-=25;SAdj[2]+=50;SAdj[3]-=25;SAdj[30]-=50;SAdj[31]+=25;
   Pos_SRV();
}
//~~~~~~~~ adjust head down
void Adj_HD(){
   SAdj[6]+=50;SAdj[7]-=25;SAdj[26]-=50;SAdj[27]+=25;SAdj[2]-=50;SAdj[3]+=25;SAdj[30]+=50;SAdj[31]-=25;
   Pos_SRV();
}
//~~~~~~~~ adjust body left
void Adj_LF(){
  SAdj[6]+=50;SAdj[7]-=25;SAdj[14]+=50;SAdj[15]-=25;SAdj[26]+=50;SAdj[27]-=25;SAdj[2]+=50;SAdj[3]-=25;SAdj[18]+=50;SAdj[19]-=25;SAdj[30]+=50;SAdj[31]-=25;
  Pos_SRV();
}
//~~~~~~~~ adjust body right
void Adj_RG(){
  SAdj[6]-=50;SAdj[7]+=25;SAdj[14]-=50;SAdj[15]+=25;SAdj[26]-=50;SAdj[27]+=25;SAdj[2]-=50;SAdj[3]+=25;SAdj[18]-=50;SAdj[19]+=25;SAdj[30]-=50;SAdj[31]+=25;
  Pos_SRV();
}
//~~~~~~~~ adjust twist left
void Adj_TL(){
   SAdj[5]-=50;SAdj[13]-=50;SAdj[25]-=50;SAdj[1]-=50;SAdj[17]-=50;SAdj[29]-=50;
   Pos_SRV();
}
//~~~~~~~~ adjust twist right
void Adj_TR(){
   SAdj[5]+=50;SAdj[13]+=50;SAdj[25]+=50;SAdj[1]+=50;SAdj[17]+=50;SAdj[29]+=50;
   Pos_SRV();
}
//~~~~~~~~ move forward
void Move_FWD(){   
  SMov[29]=SAdj[29]+1490;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1625;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1480;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1830;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1415;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1690;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1225;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1555;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1490;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1890;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1475;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1150;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1565;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1815;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1700;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1380;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1640;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1740;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1325;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1455;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1590;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1665;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1250;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1600;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1855;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1390;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1590;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1525;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1930;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1605;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1190;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1515;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1265;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1440;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1700;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1380;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1755;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1340;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
}
//~~~~~~~~ move backward
void Move_BWD(){
  SMov[29]=SAdj[29]+1440;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1700;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1380;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1755;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1340;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1515;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1265;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1590;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1525;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1930;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1605;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1190;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1665;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1250;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1600;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1855;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1390;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1740;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1325;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1455;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1590;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1815;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1700;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1380;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1640;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1890;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1475;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1150;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1565;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1690;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1225;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1555;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1490;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1490;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1625;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1480;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1830;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1415;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
}
//~~~~~~~~ turn left
void Move_LFT(){
  SMov[29]=SAdj[29]+1490;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1625;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1755;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1340;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1690;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1225;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1265;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1890;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1475;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1150;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1930;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1605;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1190;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1815;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1855;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1390;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1740;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1325;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1455;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1590;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1665;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1250;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1600;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1700;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1380;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1640;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1590;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1525;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1565;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1515;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1555;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1490;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1440;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1700;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1380;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1480;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1830;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1415;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  }
//~~~~~~~~ turn right
void Move_RGT(){
  SMov[29]=SAdj[29]+1440;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1700;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1380;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1480;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1830;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1415;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1515;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1555;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1490;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1590;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+790;SMov[19]=SAdj[19]+1890;SMov[1]=SAdj[1]+1525;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+2090;SMov[15]=SAdj[15]+990;SMov[25]=SAdj[25]+1565;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1665;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1250;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1600;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1700;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1380;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1640;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1740;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1325;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1450;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1455;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1590;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1815;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1400;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+790;SMov[3]=SAdj[3]+1890;SMov[5]=SAdj[5]+1855;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1530;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1390;SMov[26]=SAdj[26]+2090;SMov[27]=SAdj[27]+890;Send_Comm();
  SMov[29]=SAdj[29]+1890;SMov[30]=SAdj[30]+1440;SMov[31]=SAdj[31]+1490;SMov[17]=SAdj[17]+1475;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1150;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1930;SMov[6]=SAdj[6]+1440;SMov[7]=SAdj[7]+1440;SMov[13]=SAdj[13]+1605;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1190;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1690;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1550;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1225;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1780;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1680;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1265;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
  SMov[29]=SAdj[29]+1490;SMov[30]=SAdj[30]+790;SMov[31]=SAdj[31]+1990;SMov[17]=SAdj[17]+1625;SMov[18]=SAdj[18]+1440;SMov[19]=SAdj[19]+1440;SMov[1]=SAdj[1]+1300;SMov[2]=SAdj[2]+1440;SMov[3]=SAdj[3]+1440;SMov[5]=SAdj[5]+1630;SMov[6]=SAdj[6]+2090;SMov[7]=SAdj[7]+990;SMov[13]=SAdj[13]+1755;SMov[14]=SAdj[14]+1440;SMov[15]=SAdj[15]+1440;SMov[25]=SAdj[25]+1340;SMov[26]=SAdj[26]+1440;SMov[27]=SAdj[27]+1390;Send_Comm();
}
//================================================================================= Servo Move end =======================================================================
",16285,True,4411.324394696646,median
"/*

  ClipWindow.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
  
*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
}

u8g2_uint_t x = 0;

void loop(void) {
  if ( x == 0 )
    x = 40;
  else
    x--;
    
  u8g2.setFont(u8g2_font_ncenB10_tr);
  u8g2.firstPage();
  do {
  
    /* assign a clip window and draw some text into it */
    u8g2.setClipWindow(35, 11, 74, 27);  /* upper left and lower right position */
    u8g2.drawStr(x,23,""U8g2 U8g2"");
    
    /* remove clip window, draw to complete screen */
    u8g2.setMaxClipWindow(); 
    u8g2.drawFrame(34, 10, 40, 18);
    
  } while ( u8g2.nextPage() );
  delay(10);
}

",16276,True,4981.058376724533,median
"package com.ankamagames.dofus.logic.game.approach.frames
{
   import by.blooddy.crypto.MD5;
   import com.ankamagames.berilia.Berilia;
   import com.ankamagames.berilia.managers.KernelEventsManager;
   import com.ankamagames.berilia.managers.UiModuleManager;
   import com.ankamagames.berilia.types.data.UiModule;
   import com.ankamagames.berilia.types.messages.AllModulesLoadedMessage;
   import com.ankamagames.berilia.types.shortcut.Shortcut;
   import com.ankamagames.dofus.BuildInfos;
   import com.ankamagames.dofus.Constants;
   import com.ankamagames.dofus.console.moduleLUA.ConsoleLUA;
   import com.ankamagames.dofus.console.moduleLogger.Console;
   import com.ankamagames.dofus.console.moduleLogger.ModuleDebugManager;
   import com.ankamagames.dofus.datacenter.servers.Server;
   import com.ankamagames.dofus.externalnotification.ExternalNotificationManager;
   import com.ankamagames.dofus.internalDatacenter.connection.BasicCharacterWrapper;
   import com.ankamagames.dofus.internalDatacenter.connection.CreationCharacterWrapper;
   import com.ankamagames.dofus.internalDatacenter.items.ItemWrapper;
   import com.ankamagames.dofus.kernel.Kernel;
   import com.ankamagames.dofus.kernel.net.ConnectionsHandler;
   import com.ankamagames.dofus.logic.common.frames.FeatureFrame;
   import com.ankamagames.dofus.logic.common.frames.LoadingModuleFrame;
   import com.ankamagames.dofus.logic.common.frames.MiscFrame;
   import com.ankamagames.dofus.logic.common.managers.FeatureManager;
   import com.ankamagames.dofus.logic.common.managers.PlayerManager;
   import com.ankamagames.dofus.logic.connection.frames.GameStartingFrame;
   import com.ankamagames.dofus.logic.connection.frames.ServerSelectionFrame;
   import com.ankamagames.dofus.logic.connection.managers.AuthentificationManager;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterCreationAction;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterDeletionAction;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterDeselectionAction;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterNameSuggestionRequestAction;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterRemodelSelectionAction;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterReplayRequestAction;
   import com.ankamagames.dofus.logic.game.approach.actions.CharacterSelectionAction;
   import com.ankamagames.dofus.logic.game.approach.actions.GiftAssignRequestAction;
   import com.ankamagames.dofus.logic.game.common.actions.CharacterAutoConnectAction;
   import com.ankamagames.dofus.logic.game.common.actions.chat.PopupWarningCloseRequestAction;
   import com.ankamagames.dofus.logic.game.common.frames.AdministrablePopupFrame;
   import com.ankamagames.dofus.logic.game.common.frames.AlignmentFrame;
   import com.ankamagames.dofus.logic.game.common.frames.AllianceFrame;
   import com.ankamagames.dofus.logic.game.common.frames.AveragePricesFrame;
   import com.ankamagames.dofus.logic.game.common.frames.CameraControlFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ChatFrame;
   import com.ankamagames.dofus.logic.game.common.frames.CommonUiFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ContextChangeFrame;
   import com.ankamagames.dofus.logic.game.common.frames.EmoticonFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ExternalGameFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ForgettableSpellsUiFrame;
   import com.ankamagames.dofus.logic.game.common.frames.HouseFrame;
   import com.ankamagames.dofus.logic.game.common.frames.IdolsFrame;
   import com.ankamagames.dofus.logic.game.common.frames.InventoryManagementFrame;
   import com.ankamagames.dofus.logic.game.common.frames.JobsFrame;
   import com.ankamagames.dofus.logic.game.common.frames.LivingObjectFrame;
   import com.ankamagames.dofus.logic.game.common.frames.MountFrame;
   import com.ankamagames.dofus.logic.game.common.frames.PartyManagementFrame;
   import com.ankamagames.dofus.logic.game.common.frames.PlayedCharacterUpdatesFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ProgressionFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ProtectPishingFrame;
   import com.ankamagames.dofus.logic.game.common.frames.QuestFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ScreenCaptureFrame;
   import com.ankamagames.dofus.logic.game.common.frames.ServerTransferFrame;
   import com.ankamagames.dofus.logic.game.common.frames.SocialFrame;
   import com.ankamagames.dofus.logic.game.common.frames.SpellInventoryManagementFrame;
   import com.ankamagames.dofus.logic.game.common.frames.StackManagementFrame;
   import com.ankamagames.dofus.logic.game.common.frames.SynchronisationFrame;
   import com.ankamagames.dofus.logic.game.common.frames.TinselFrame;
   import com.ankamagames.dofus.logic.game.common.frames.WorldFrame;
   import com.ankamagames.dofus.logic.game.common.managers.DebtManager;
   import com.ankamagames.dofus.logic.game.common.managers.InactivityManager;
   import com.ankamagames.dofus.logic.game.common.managers.PlayedCharacterManager;
   import com.ankamagames.dofus.logic.game.common.managers.TimeManager;
   import com.ankamagames.dofus.logic.game.roleplay.frames.RoleplayIntroductionFrame;
   import com.ankamagames.dofus.logic.game.spin2.chat.ChatServiceManager;
   import com.ankamagames.dofus.logic.shield.SecureModeManager;
   import com.ankamagames.dofus.misc.interClient.InterClientManager;
   import com.ankamagames.dofus.misc.lists.HookList;
   import com.ankamagames.dofus.misc.stats.StatisticsManager;
   import com.ankamagames.dofus.misc.utils.errormanager.DofusErrorHandler;
   import com.ankamagames.dofus.network.ProtocolConstantsEnum;
   import com.ankamagames.dofus.network.enums.BuildTypeEnum;
   import com.ankamagames.dofus.network.enums.CharacterDeletionErrorEnum;
   import com.ankamagames.dofus.network.enums.CharacterRemodelingEnum;
   import com.ankamagames.dofus.network.enums.GameServerTypeEnum;
   import com.ankamagames.dofus.network.messages.authorized.ConsoleCommandsListMessage;
   import com.ankamagames.dofus.network.messages.game.approach.AccountCapabilitiesMessage;
   import com.ankamagames.dofus.network.messages.game.approach.AlreadyConnectedMessage;
   import com.ankamagames.dofus.network.messages.game.approach.AuthenticationTicketAcceptedMessage;
   import com.ankamagames.dofus.network.messages.game.approach.AuthenticationTicketMessage;
   import com.ankamagames.dofus.network.messages.game.approach.AuthenticationTicketRefusedMessage;
   import com.ankamagames.dofus.network.messages.game.approach.HelloGameMessage;
   import com.ankamagames.dofus.network.messages.game.basic.BasicTimeMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.BasicCharactersListMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterFirstSelectionMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterReplayWithRemodelRequestMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterSelectedErrorMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterSelectedForceMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterSelectedForceReadyMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterSelectedSuccessMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterSelectionMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharacterSelectionWithRemodelMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharactersListErrorMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharactersListMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharactersListRequestMessage;
   import com.ankamagames.dofus.network.messages.game.character.choice.CharactersListWithRemodelingMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterCanBeCreatedRequestMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterCanBeCreatedResultMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterCreationRequestMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterCreationResultMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterNameSuggestionFailureMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterNameSuggestionRequestMessage;
   import com.ankamagames.dofus.network.messages.game.character.creation.CharacterNameSuggestionSuccessMessage;
   import com.ankamagames.dofus.network.messages.game.character.deletion.CharacterDeletionErrorMessage;
   import com.ankamagames.dofus.network.messages.game.character.deletion.CharacterDeletionRequestMessage;
   import com.ankamagames.dofus.network.messages.game.character.replay.CharacterReplayRequestMessage;
   import com.ankamagames.dofus.network.messages.game.context.GameContextCreateRequestMessage;
   import com.ankamagames.dofus.network.messages.game.context.roleplay.fight.arena.GameRolePlayArenaSwitchToFightServerMessage;
   import com.ankamagames.dofus.network.messages.game.moderation.PopupWarningCloseRequestMessage;
   import com.ankamagames.dofus.network.messages.game.moderation.PopupWarningClosedMessage;
   import com.ankamagames.dofus.network.messages.game.startup.StartupActionFinishedMessage;
   import com.ankamagames.dofus.network.messages.game.startup.StartupActionsExecuteMessage;
   import com.ankamagames.dofus.network.messages.game.startup.StartupActionsListMessage;
   import com.ankamagames.dofus.network.messages.game.startup.StartupActionsObjetAttributionMessage;
   import com.ankamagames.dofus.network.messages.security.ClientKeyMessage;
   import com.ankamagames.dofus.network.types.game.character.choice.CharacterBaseInformations;
   import com.ankamagames.dofus.network.types.game.character.choice.CharacterHardcoreOrEpicInformations;
   import com.ankamagames.dofus.network.types.game.character.choice.CharacterToRemodelInformations;
   import com.ankamagames.dofus.network.types.game.character.choice.RemodelingInformation;
   import com.ankamagames.dofus.network.types.game.data.items.ObjectItemInformationWithQuantity;
   import com.ankamagames.dofus.network.types.game.startup.StartupActionAddObject;
   import com.ankamagames.dofus.scripts.api.CameraApi;
   import com.ankamagames.dofus.scripts.api.EntityApi;
   import com.ankamagames.dofus.scripts.api.ScriptSequenceApi;
   import com.ankamagames.dofus.types.data.ServerCommand;
   import com.ankamagames.dofus.uiApi.DataApi;
   import com.ankamagames.dofus.uiApi.SoundApi;
   import com.ankamagames.jerakine.data.I18n;
   import com.ankamagames.jerakine.data.XmlConfig;
   import com.ankamagames.jerakine.logger.Log;
   import com.ankamagames.jerakine.logger.LogLogger;
   import com.ankamagames.jerakine.logger.Logger;
   import com.ankamagames.jerakine.lua.LuaPlayer;
   import com.ankamagames.jerakine.managers.LangManager;
   import com.ankamagames.jerakine.managers.OptionManager;
   import com.ankamagames.jerakine.managers.StoreDataManager;
   import com.ankamagames.jerakine.messages.ConnectionResumedMessage;
   import com.ankamagames.jerakine.messages.Frame;
   import com.ankamagames.jerakine.messages.Message;
   import com.ankamagames.jerakine.network.messages.ServerConnectionFailedMessage;
   import com.ankamagames.jerakine.script.ScriptsManager;
   import com.ankamagames.jerakine.types.DataStoreType;
   import com.ankamagames.jerakine.types.enums.DataStoreEnum;
   import com.ankamagames.jerakine.types.enums.Priority;
   import com.ankamagames.jerakine.utils.benchmark.monitoring.FpsManager;
   import com.ankamagames.jerakine.utils.system.AirScanner;
   import flash.display.Loader;
   import flash.system.ApplicationDomain;
   import flash.system.LoaderContext;
   import flash.utils.getQualifiedClassName;
   import flash.utils.setTimeout;
   import scopart.raven.RavenClient;
   
   public class GameServerApproachFrame implements Frame
   {
      
      protected static const _log:Logger = Log.getLogger(getQualifiedClassName(GameServerApproachFrame));
      
      private static var _changeLogLoader:Loader = new Loader();
      
      public static var authenticationTicketAccepted:Boolean = false;
       
      
      private const LOADING_TIMEOUT:uint = 60000.0;
      
      private var _charactersList:Vector.<BasicCharacterWrapper>;
      
      private var _charactersToRemodelList:Array;
      
      private var _kernel:KernelEventsManager;
      
      private var _gmaf:LoadingModuleFrame;
      
      private var _loadingStart:Number;
      
      private var _waitingMessages:Vector.<Message>;
      
      private var _cssmsg:CharacterSelectedSuccessMessage;
      
      private var _requestedCharacterId:Number;
      
      private var _requestedToRemodelCharacterId:Number;
      
      private var _waitingForListRefreshAfterDeletion:Boolean;
      
      private var _lc:LoaderContext;
      
      private var commonMod:Object;
      
      private var _giftList:Array;
      
      private var _charaListMinusDeadPeople:Array;
      
      private var _reconnectMsgSend:Boolean = false;
      
      private var _openCharsList:Boolean = true;
      
      public function GameServerApproachFrame()
      {
         this._charactersList = new Vector.<BasicCharacterWrapper>();
         this._charactersToRemodelList = [];
         this._kernel = KernelEventsManager.getInstance();
         this._lc = new LoaderContext(false,ApplicationDomain.currentDomain);
         this.commonMod = UiModuleManager.getInstance().getModule(""Ankama_Common"").mainClass;
         this._giftList = [];
         this._charaListMinusDeadPeople = [];
         super();
      }
      
      public function get priority() : int
      {
         return Priority.NORMAL;
      }
      
      public function get giftList() : Array
      {
         return this._giftList;
      }
      
      public function get charaListMinusDeadPeople() : Array
      {
         return this._charaListMinusDeadPeople;
      }
      
      public function get requestedCharaId() : Number
      {
         return this._requestedCharacterId;
      }
      
      public function set requestedCharaId(id:Number) : void
      {
         this._requestedCharacterId = id;
      }
      
      public function isCharacterWaitingForChange(id:Number) : Boolean
      {
         if(this._charactersToRemodelList[id])
         {
            return true;
         }
         return false;
      }
      
      public function pushed() : Boolean
      {
         SecureModeManager.getInstance().checkMigrate();
         AirScanner.allowByteCodeExecution(this._lc,true);
         Kernel.getWorker().addFrame(new MiscFrame());
         Kernel.getWorker().addFrame(new FeatureFrame());
         return true;
      }
      
      public function process(msg:Message) : Boolean
      {
         var perso:BasicCharacterWrapper = null;
         var characterId:Number = NaN;
         var isReplay:Boolean = false;
         var atmsg:AuthenticationTicketMessage = null;
         var atrmsg:AuthenticationTicketRefusedMessage = null;
         var scfMsg:ServerConnectionFailedMessage = null;
         var acmsg:AlreadyConnectedMessage = null;
         var clmsg:CharactersListMessage = null;
         var unusableCharacters:Vector.<Number> = null;
         var o:BasicCharacterWrapper = null;
         var unusable:Boolean = false;
         var server:Server = null;
         var bonusXp:int = 0;
         var mod:UiModule = null;
         var dst:DataStoreType = null;
         var isCharacterCreationDisplayForced:Boolean = false;
         var bclmsg:BasicCharactersListMessage = null;
         var b:BasicCharacterWrapper = null;
         var ccbcmsg:CharacterCanBeCreatedResultMessage = null;
         var accmsg:AccountCapabilitiesMessage = null;
         var cca:CharacterCreationAction = null;
         var ccmsg:CharacterCreationRequestMessage = null;
         var colors:Vector.<int> = null;
         var ccrmsg:CharacterCreationResultMessage = null;
         var cda:CharacterDeletionAction = null;
         var cdrmsg:CharacterDeletionRequestMessage = null;
         var cdemsg:CharacterDeletionErrorMessage = null;
         var reason:String = null;
         var cnsra:CharacterNameSuggestionRequestAction = null;
         var cnsrmsg:CharacterNameSuggestionRequestMessage = null;
         var cnssmsg:CharacterNameSuggestionSuccessMessage = null;
         var cnsfmsg:CharacterNameSuggestionFailureMessage = null;
         var crsa:CharacterRemodelSelectionAction = null;
         var remodel:RemodelingInformation = null;
         var tempColorsArray:Vector.<int> = null;
         var characterToConnect:BasicCharacterWrapper = null;
         var currentServer:Server = null;
         var bTutorial:Boolean = false;
         var cssmsg:CharacterSelectedSuccessMessage = null;
         var isRelease:* = false;
         var gccrmsg:GameContextCreateRequestMessage = null;
         var soundApi:SoundApi = null;
         var devMode:* = false;
         var now:Number = NaN;
         var delta:Number = NaN;
         var csemsg:CharacterSelectedErrorMessage = null;
         var btmsg:BasicTimeMessage = null;
         var date:Date = null;
         var salm:StartupActionsListMessage = null;
         var cclMsg:ConsoleCommandsListMessage = null;
         var stf:ServerTransferFrame = null;
         var pwcrmsg:PopupWarningCloseRequestMessage = null;
         var ccbcrm:CharacterCanBeCreatedRequestMessage = null;
         var clwrmsg:CharactersListWithRemodelingMessage = null;
         var ctri:CharacterToRemodelInformations = null;
         var chi:CharacterHardcoreOrEpicInformations = null;
         var featureManager:FeatureManager = null;
         var bonusXpFeatureActivated:Boolean = false;
         var cbi:CharacterBaseInformations = null;
         var cbi2:CharacterBaseInformations = null;
         var charToConnect:BasicCharacterWrapper = null;
         var saem:StartupActionsExecuteMessage = null;
         var ccbcrmsg:CharacterCanBeCreatedRequestMessage = null;
         var bChi:CharacterHardcoreOrEpicInformations = null;
         var bCbi:CharacterBaseInformations = null;
         var c:* = undefined;
         var colorIndex:* = undefined;
         var colorInteger:* = 0;
         var person2:Object = null;
         var crwrrmsg:CharacterReplayWithRemodelRequestMessage = null;
         var cswrmsg:CharacterSelectionWithRemodelMessage = null;
         var charToRemodel:Object = null;
         var indexedColors:Vector.<int> = null;
         var char:CreationCharacterWrapper = null;
         var modificationModules:Array = null;
         var mandatoryModules:Array = null;
         var firstSelection:Boolean = false;
         var cfsmsg:CharacterFirstSelectionMessage = null;
         var crrmsg:CharacterReplayRequestMessage = null;
         var csmsg:CharacterSelectionMessage = null;
         var j:int = 0;
         var bchar:BasicCharacterWrapper = null;
         var flashKeyMsg:ClientKeyMessage = null;
         var fpsManagerState:uint = 0;
         var i:uint = 0;
         var luaPlayer:LuaPlayer = null;
         var tag:Object = null;
         var gift:StartupActionAddObject = null;
         var _items:Array = null;
         var item:ObjectItemInformationWithQuantity = null;
         var oj:Object = null;
         var iw:ItemWrapper = null;
         var gar:GiftAssignRequestAction = null;
         var sao:StartupActionsObjetAttributionMessage = null;
         var safm:StartupActionFinishedMessage = null;
         var indexToDelete:int = 0;
         var giftAction:Object = null;
         var cmdIndex:uint = 0;
         switch(true)
         {
            case msg is HelloGameMessage:
               ConnectionsHandler.confirmGameServerConnection();
               authenticationTicketAccepted = false;
               atmsg = new AuthenticationTicketMessage();
               atmsg.initAuthenticationTicketMessage(LangManager.getInstance().getEntry(""config.lang.current""),AuthentificationManager.getInstance().gameServerTicket);
               ConnectionsHandler.getConnection().send(atmsg);
               InactivityManager.getInstance().start();
               this._kernel.processCallback(HookList.AuthenticationTicket);
               return true;
            case msg is AuthenticationTicketAcceptedMessage:
               setTimeout(this.requestCharactersList,500);
               authenticationTicketAccepted = true;
               this._kernel.processCallback(HookList.AuthenticationTicketAccepted);
               return true;
            case msg is AuthenticationTicketRefusedMessage:
               atrmsg = msg as AuthenticationTicketRefusedMessage;
               authenticationTicketAccepted = false;
               this._kernel.processCallback(HookList.AuthenticationTicketRefused);
               return true;
            case msg is ServerConnectionFailedMessage:
               scfMsg = ServerConnectionFailedMessage(msg);
               authenticationTicketAccepted = false;
               if(scfMsg.failedConnection == ConnectionsHandler.getConnection().getSubConnection(scfMsg))
               {
                  PlayerManager.getInstance().destroy();
                  this.commonMod.openPopup(I18n.getUiText(""ui.common.error""),I18n.getUiText(""ui.connexion.gameConnexionFailed""),[I18n.getUiText(""ui.common.ok"")],[this.onEscapePopup],this.onEscapePopup,this.onEscapePopup);
                  KernelEventsManager.getInstance().processCallback(HookList.SelectedServerFailed);
               }
               return true;
            case msg is AlreadyConnectedMessage:
               acmsg = AlreadyConnectedMessage(msg);
               PlayerManager.getInstance().wasAlreadyConnected = true;
               KernelEventsManager.getInstance().processCallback(HookList.AlreadyConnected);
               return true;
            case msg is CharactersListMessage:
               clmsg = msg as CharactersListMessage;
               if(this._waitingForListRefreshAfterDeletion)
               {
                  ccbcrm = new CharacterCanBeCreatedRequestMessage();
                  ccbcrm.initCharacterCanBeCreatedRequestMessage();
                  ConnectionsHandler.getConnection().send(ccbcrm);
                  this._waitingForListRefreshAfterDeletion = false;
               }
               unusableCharacters = new Vector.<Number>();
               if(msg is CharactersListWithRemodelingMessage)
               {
                  clwrmsg = msg as CharactersListWithRemodelingMessage;
                  for each(ctri in clwrmsg.charactersToRemodel)
                  {
                     this._charactersToRemodelList[ctri.id] = ctri;
                  }
               }
               this._charactersList = new Vector.<BasicCharacterWrapper>();
               unusable = false;
               server = PlayerManager.getInstance().server;
               bonusXp = 1;
               if(FeatureManager.getInstance().isFeatureWithKeywordEnabled(""server.heroic"") || server.gameTypeId == GameServerTypeEnum.SERVER_TYPE_EPIC)
               {
                  for each(chi in clmsg.characters)
                  {
                     if(unusableCharacters.indexOf(chi.id) != -1)
                     {
                        unusable = true;
                     }
                     if(chi.deathMaxLevel > chi.level)
                     {
                        bonusXp = 6;
                     }
                     else
                     {
                        bonusXp = 3;
                     }
                     o = BasicCharacterWrapper.create(chi.id,chi.name,chi.level,chi.entityLook,chi.breed,chi.sex,chi.deathState,chi.deathCount,chi.deathMaxLevel,bonusXp,unusable);
                     this._charactersList.push(o);
                  }
               }
               else
               {
                  featureManager = FeatureManager.getInstance();
                  bonusXpFeatureActivated = !featureManager || featureManager.isFeatureWithKeywordEnabled(""character.xp.bonusForYoungerCharacters"");
                  for each(cbi in clmsg.characters)
                  {
                     bonusXp = 1;
                     if(unusableCharacters.indexOf(cbi.id) != -1)
                     {
                        unusable = true;
                     }
                     if(bonusXpFeatureActivated)
                     {
                        for each(cbi2 in clmsg.characters)
                        {
                           if(cbi2.id != cbi.id && cbi2.level > cbi.level && bonusXp < 4)
                           {
                              bonusXp++;
                           }
                        }
                     }
                     o = BasicCharacterWrapper.create(cbi.id,cbi.name,cbi.level,cbi.entityLook,cbi.breed,cbi.sex,0,0,0,bonusXp,unusable);
                     this._charactersList.push(o);
                  }
               }
               PlayerManager.getInstance().charactersList = this._charactersList;
               mod = UiModuleManager.getInstance().getModule(""Ankama_Connection"");
               dst = new DataStoreType(""AccountModule_"" + mod.id,true,DataStoreEnum.LOCATION_LOCAL,DataStoreEnum.BIND_ACCOUNT);
               isCharacterCreationDisplayForced = StoreDataManager.getInstance().getData(dst,""forceCharacterCreationDisplay"");
               if(this._charactersList.length && !isCharacterCreationDisplayForced)
               {
                  this._openCharsList = true;
                  charToConnect = this.getCharacterToConnect();
                  if(clmsg.hasStartupActions && !charToConnect)
                  {
                     saem = new StartupActionsExecuteMessage();
                     saem.initStartupActionsExecuteMessage();
                     ConnectionsHandler.getConnection().send(saem);
                     this._openCharsList = false;
                  }
                  else if(charToConnect)
                  {
                     this.launchAutoConnect(charToConnect,server);
                  }
                  if(this._openCharsList)
                  {
                     if(!Berilia.getInstance().getUi(""characterSelection""))
                     {
                        this._kernel.processCallback(HookList.CharacterSelectionStart,this._charactersList);
                     }
                     else
                     {
                        this._kernel.processCallback(HookList.CharactersListUpdated,this._charactersList);
                     }
                  }
               }
               else
               {
                  this._kernel.processCallback(HookList.CharacterCreationStart,[[""create""],true]);
                  this._kernel.processCallback(HookList.CharactersListUpdated,this._charactersList);
               }
               return true;
            case msg is BasicCharactersListMessage:
               bclmsg = msg as BasicCharactersListMessage;
               if(this._waitingForListRefreshAfterDeletion)
               {
                  ccbcrmsg = new CharacterCanBeCreatedRequestMessage();
                  ccbcrmsg.initCharacterCanBeCreatedRequestMessage();
                  ConnectionsHandler.getConnection().send(ccbcrmsg);
                  this._waitingForListRefreshAfterDeletion = false;
               }
               this._charactersList = new Vector.<BasicCharacterWrapper>();
               if(FeatureManager.getInstance().isFeatureWithKeywordEnabled(""server.heroic"") || PlayerManager.getInstance().server.gameTypeId == GameServerTypeEnum.SERVER_TYPE_EPIC)
               {
                  for each(bChi in bclmsg.characters)
                  {
                     b = BasicCharacterWrapper.create(bChi.id,bChi.name,bChi.level,bChi.entityLook,bChi.breed,bChi.sex,bChi.deathState,bChi.deathCount,bChi.deathMaxLevel,1,false);
                     this._charactersList.push(b);
                  }
               }
               else
               {
                  for each(bCbi in bclmsg.characters)
                  {
                     b = BasicCharacterWrapper.create(bCbi.id,bCbi.name,bCbi.level,bCbi.entityLook,bCbi.breed,bCbi.sex,0,0,0,1,false);
                     this._charactersList.push(b);
                  }
               }
               PlayerManager.getInstance().charactersList = this._charactersList;
               return true;
            case msg is CharactersListErrorMessage:
               this.commonMod.openPopup(I18n.getUiText(""ui.common.error""),I18n.getUiText(""ui.connexion.charactersListError""),[I18n.getUiText(""ui.common.ok"")]);
               return false;
            case msg is CharacterCanBeCreatedResultMessage:
               ccbcmsg = msg as CharacterCanBeCreatedResultMessage;
               PlayerManager.getInstance().canCreateNewCharacter = ccbcmsg.yesYouCan;
               KernelEventsManager.getInstance().processCallback(HookList.CharacterCanBeCreated);
               return true;
            case msg is AccountCapabilitiesMessage:
               accmsg = msg as AccountCapabilitiesMessage;
               this._kernel.processCallback(HookList.TutorielAvailable,accmsg.tutorialAvailable);
               this._kernel.processCallback(HookList.BreedsAvailable,accmsg.breedsAvailable,accmsg.breedsVisible);
               PlayerManager.getInstance().adminStatus = accmsg.status;
               PlayerManager.getInstance().canCreateNewCharacter = accmsg.canCreateNewCharacter;
               KernelEventsManager.getInstance().processCallback(HookList.CharacterCreationStart,[[""create""]]);
               return true;
            case msg is CharacterCreationAction:
               cca = msg as CharacterCreationAction;
               ccmsg = new CharacterCreationRequestMessage();
               colors = new Vector.<int>();
               for each(c in cca.colors)
               {
                  colors.push(c);
               }
               while(colors.length < ProtocolConstantsEnum.MAX_PLAYER_COLOR)
               {
                  colors.push(-1);
               }
               ccmsg.initCharacterCreationRequestMessage(cca.name,cca.breed,cca.sex,colors,cca.head);
               ConnectionsHandler.getConnection().send(ccmsg);
               return true;
            case msg is CharacterCreationResultMessage:
               ccrmsg = msg as CharacterCreationResultMessage;
               this._kernel.processCallback(HookList.CharacterCreationResult,ccrmsg.result);
               return true;
            case msg is CharacterDeletionAction:
               cda = msg as CharacterDeletionAction;
               this._waitingForListRefreshAfterDeletion = true;
               cdrmsg = new CharacterDeletionRequestMessage();
               cdrmsg.initCharacterDeletionRequestMessage(cda.id,MD5.hash(cda.id + ""~"" + cda.answer));
               ConnectionsHandler.getConnection().send(cdrmsg);
               return true;
            case msg is CharacterDeletionErrorMessage:
               cdemsg = msg as CharacterDeletionErrorMessage;
               this._waitingForListRefreshAfterDeletion = false;
               reason = """";
               if(cdemsg.reason == CharacterDeletionErrorEnum.DEL_ERR_TOO_MANY_CHAR_DELETION)
               {
                  reason = ""TooManyDeletion"";
               }
               else if(cdemsg.reason == CharacterDeletionErrorEnum.DEL_ERR_BAD_SECRET_ANSWER)
               {
                  reason = ""WrongAnswer"";
               }
               else if(cdemsg.reason == CharacterDeletionErrorEnum.DEL_ERR_RESTRICED_ZONE)
               {
                  reason = ""UnsecureMode"";
               }
               this._kernel.processCallback(HookList.CharacterDeletionError,reason);
               this._requestedCharacterId = 0;
               return true;
            case msg is CharacterNameSuggestionRequestAction:
               cnsra = msg as CharacterNameSuggestionRequestAction;
               cnsrmsg = new CharacterNameSuggestionRequestMessage();
               cnsrmsg.initCharacterNameSuggestionRequestMessage();
               ConnectionsHandler.getConnection().send(cnsrmsg);
               return true;
            case msg is CharacterNameSuggestionSuccessMessage:
               cnssmsg = msg as CharacterNameSuggestionSuccessMessage;
               this._kernel.processCallback(HookList.CharacterNameSuggestioned,cnssmsg.suggestion);
               return true;
            case msg is CharacterNameSuggestionFailureMessage:
               cnsfmsg = msg as CharacterNameSuggestionFailureMessage;
               _log.error(""Generation de nom impossible !"");
               return true;
            case msg is CharacterSelectedForceMessage:
               if(!this._reconnectMsgSend)
               {
                  Kernel.beingInReconection = true;
                  characterId = CharacterSelectedForceMessage(msg).id;
                  this._reconnectMsgSend = true;
                  ConnectionsHandler.getConnection().send(new CharacterSelectedForceReadyMessage());
               }
               return true;
            case msg is CharacterRemodelSelectionAction:
               crsa = msg as CharacterRemodelSelectionAction;
               remodel = new RemodelingInformation();
               remodel.sex = crsa.sex;
               remodel.breed = crsa.breed;
               remodel.cosmeticId = crsa.cosmeticId;
               remodel.name = crsa.name;
               tempColorsArray = new Vector.<int>();
               for(colorIndex in crsa.colors)
               {
                  colorInteger = int(crsa.colors[colorIndex]);
                  if(colorInteger >= 0)
                  {
                     colorInteger &= 16777215;
                     tempColorsArray.push(colorInteger | int(colorIndex) + 1 << 24);
                  }
               }
               remodel.colors = tempColorsArray;
               if(FeatureManager.getInstance().isFeatureWithKeywordEnabled(""server.heroic"") || PlayerManager.getInstance().server.gameTypeId == GameServerTypeEnum.SERVER_TYPE_EPIC)
               {
                  for each(person2 in this._charactersList)
                  {
                     if(person2.id == this._requestedToRemodelCharacterId)
                     {
                        if(person2.deathState == 1)
                        {
                           isReplay = true;
                        }
                        else if(person2.deathState == 0)
                        {
                           isReplay = false;
                        }
                        else
                        {
                           this.commonMod.openPopup(I18n.getUiText(""ui.common.error""),I18n.getUiText(""ui.common.cantSelectThisCharacterLimb""),[I18n.getUiText(""ui.common.ok"")]);
                        }
                     }
                  }
               }
               else
               {
                  isReplay = false;
               }
               if(isReplay)
               {
                  crwrrmsg = new CharacterReplayWithRemodelRequestMessage();
                  crwrrmsg.initCharacterReplayWithRemodelRequestMessage(this._requestedToRemodelCharacterId,remodel);
                  ConnectionsHandler.getConnection().send(crwrrmsg);
               }
               else
               {
                  cswrmsg = new CharacterSelectionWithRemodelMessage();
                  cswrmsg.initCharacterSelectionWithRemodelMessage(this._requestedToRemodelCharacterId,remodel);
                  ConnectionsHandler.getConnection().send(cswrmsg);
               }
               return true;
            case msg is CharacterDeselectionAction:
               this._requestedCharacterId = 0;
               return true;
            case msg is CharacterAutoConnectAction:
               characterToConnect = this.getCharacterToConnect();
               currentServer = PlayerManager.getInstance().server;
               if(characterToConnect && currentServer)
               {
                  this.launchAutoConnect(characterToConnect,currentServer);
               }
               break;
            case msg is CharacterSelectionAction:
            case msg is CharacterReplayRequestAction:
               if(this._requestedCharacterId)
               {
                  return false;
               }
               bTutorial = false;
               if(msg is CharacterSelectionAction)
               {
                  characterId = (msg as CharacterSelectionAction).characterId;
                  bTutorial = (msg as CharacterSelectionAction).btutoriel;
                  isReplay = false;
               }
               else if(msg is CharacterReplayRequestAction)
               {
                  characterId = (msg as CharacterReplayRequestAction).characterId;
                  bTutorial = false;
                  isReplay = true;
               }
               this._requestedCharacterId = characterId;
               if(this._charactersToRemodelList[characterId])
               {
                  this._requestedToRemodelCharacterId = characterId;
                  charToRemodel = this._charactersToRemodelList[characterId];
                  indexedColors = this.getCharacterColorsInformations(charToRemodel);
                  char = CreationCharacterWrapper.create(charToRemodel.name,charToRemodel.sex,charToRemodel.breed,charToRemodel.cosmeticId,indexedColors);
                  for each(perso in this._charactersList)
                  {
                     if(perso.id == characterId)
                     {
                        char.entityLook = perso.entityLook;
                     }
                  }
                  modificationModules = [];
                  if((charToRemodel.possibleChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_BREED) > 0)
                  {
                     modificationModules.push(""rebreed"");
                  }
                  if((charToRemodel.possibleChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_COLORS) > 0)
                  {
                     modificationModules.push(""recolor"");
                  }
                  if((charToRemodel.possibleChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_COSMETIC) > 0)
                  {
                     modificationModules.push(""relook"");
                  }
                  if((charToRemodel.possibleChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_NAME) > 0)
                  {
                     modificationModules.push(""rename"");
                  }
                  if((charToRemodel.possibleChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_GENDER) > 0)
                  {
                     modificationModules.push(""regender"");
                  }
                  mandatoryModules = [];
                  if((charToRemodel.mandatoryChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_BREED) > 0)
                  {
                     mandatoryModules.push(""rebreed"");
                  }
                  if((charToRemodel.mandatoryChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_COLORS) > 0)
                  {
                     mandatoryModules.push(""recolor"");
                  }
                  if((charToRemodel.mandatoryChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_COSMETIC) > 0)
                  {
                     mandatoryModules.push(""relook"");
                  }
                  if((charToRemodel.mandatoryChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_NAME) > 0)
                  {
                     mandatoryModules.push(""rename"");
                  }
                  if((charToRemodel.mandatoryChangeMask & CharacterRemodelingEnum.CHARACTER_REMODELING_GENDER) > 0)
                  {
                     mandatoryModules.push(""regender"");
                  }
                  if((charToRemodel.mandatoryChangeMask & CharacterRemodelingEnum.CHARACTER_OPT_REMODELING_NAME) > 0)
                  {
                     modificationModules.push(""rename"");
                  }
                  this._kernel.processCallback(HookList.CharacterCreationStart,[modificationModules,mandatoryModules,char]);
               }
               else
               {
                  this._requestedToRemodelCharacterId = 0;
                  firstSelection = bTutorial;
                  if(bTutorial)
                  {
                     cfsmsg = new CharacterFirstSelectionMessage();
                     cfsmsg.initCharacterFirstSelectionMessage(characterId,true);
                     ConnectionsHandler.getConnection().send(cfsmsg);
                  }
                  else if(isReplay)
                  {
                     crrmsg = new CharacterReplayRequestMessage();
                     crrmsg.initCharacterReplayRequestMessage(characterId);
                     ConnectionsHandler.getConnection().send(crrmsg);
                  }
                  else
                  {
                     csmsg = new CharacterSelectionMessage();
                     csmsg.initCharacterSelectionMessage(characterId);
                     ConnectionsHandler.getConnection().send(csmsg);
                  }
               }
               return true;
               break;
            case msg is CharacterSelectedSuccessMessage:
               cssmsg = msg as CharacterSelectedSuccessMessage;
               this._loadingStart = new Date().time;
               ConnectionsHandler.pause();
               if(Kernel.getWorker().getFrame(ServerSelectionFrame))
               {
                  Kernel.getWorker().removeFrame(Kernel.getWorker().getFrame(ServerSelectionFrame));
               }
               if(this._gmaf == null)
               {
                  this._gmaf = new LoadingModuleFrame();
                  Kernel.getWorker().addFrame(this._gmaf);
               }
               PlayedCharacterManager.getInstance().infos = cssmsg.infos;
               DataStoreType.CHARACTER_ID = cssmsg.infos.id.toString();
               Kernel.getWorker().pause();
               this._cssmsg = cssmsg;
               UiModuleManager.getInstance().reset();
               if(PlayerManager.getInstance().hasRights)
               {
                  UiModuleManager.getInstance().init(Constants.PRE_GAME_MODULE,false);
               }
               else
               {
                  UiModuleManager.getInstance().init(Constants.PRE_GAME_MODULE.concat(Constants.ADMIN_MODULE),false);
               }
               Dofus.getInstance().renameApp(cssmsg.infos.name + "" - Dofus "" + BuildInfos.VERSION.toStringForAppName());
               ExternalNotificationManager.getInstance().init();
               if(cssmsg.isCollectingStats)
               {
                  StatisticsManager.getInstance().startStats(""shortcuts"");
               }
               else
               {
                  StatisticsManager.getInstance().quit();
               }
               if(cssmsg.infos.id == this._requestedToRemodelCharacterId)
               {
                  for(j = 0; j < this._charactersList.length; j++)
                  {
                     bchar = this._charactersList[j];
                     if(bchar.id == cssmsg.infos.id)
                     {
                        this._charactersList[j] = BasicCharacterWrapper.create(bchar.id,cssmsg.infos.name,cssmsg.infos.level,cssmsg.infos.entityLook,cssmsg.infos.breed,cssmsg.infos.sex,0,0,bchar.bonusXp);
                        break;
                     }
                  }
               }
               DebtManager.clean();
               return true;
            case msg is AllModulesLoadedMessage:
               _log.warn(""GameServerApproachFrame AllModulesLoaded"");
               this._gmaf = null;
               isRelease = BuildInfos.BUILD_TYPE == BuildTypeEnum.RELEASE;
               LogLogger.activeLog(!isRelease || isRelease && DofusErrorHandler.debugManuallyActivated);
               Kernel.getWorker().addFrame(new WorldFrame());
               Kernel.getWorker().addFrame(new AlignmentFrame());
               Kernel.getWorker().addFrame(new SynchronisationFrame());
               Kernel.getWorker().addFrame(new LivingObjectFrame());
               Kernel.getWorker().addFrame(new AllianceFrame());
               Kernel.getWorker().addFrame(new PlayedCharacterUpdatesFrame());
               Kernel.getWorker().addFrame(new SocialFrame());
               Kernel.getWorker().addFrame(new SpellInventoryManagementFrame());
               Kernel.getWorker().addFrame(new InventoryManagementFrame());
               Kernel.getWorker().addFrame(new ContextChangeFrame());
               Kernel.getWorker().addFrame(new CommonUiFrame());
               Kernel.getWorker().addFrame(new ProgressionFrame());
               Kernel.getWorker().addFrame(new ChatFrame());
               Kernel.getWorker().addFrame(new JobsFrame());
               Kernel.getWorker().addFrame(new MountFrame());
               Kernel.getWorker().addFrame(new EmoticonFrame());
               Kernel.getWorker().addFrame(new QuestFrame());
               Kernel.getWorker().addFrame(new TinselFrame());
               Kernel.getWorker().addFrame(new PartyManagementFrame());
               Kernel.getWorker().addFrame(new ProtectPishingFrame());
               Kernel.getWorker().addFrame(new StackManagementFrame());
               Kernel.getWorker().addFrame(new ExternalGameFrame());
               Kernel.getWorker().addFrame(new AveragePricesFrame());
               Kernel.getWorker().addFrame(new CameraControlFrame());
               Kernel.getWorker().addFrame(new IdolsFrame());
               Kernel.getWorker().addFrame(new RoleplayIntroductionFrame());
               Kernel.getWorker().addFrame(new ScreenCaptureFrame());
               Kernel.getWorker().addFrame(new AdministrablePopupFrame());
               if(FeatureManager.getInstance().isFeatureWithKeywordEnabled(""character.spell.forgettable""))
               {
                  Kernel.getWorker().addFrame(new ForgettableSpellsUiFrame());
               }
               if(!Kernel.getWorker().contains(HouseFrame))
               {
                  Kernel.getWorker().addFrame(new HouseFrame());
               }
               Kernel.getWorker().removeFrame(Kernel.getWorker().getFrame(GameStartingFrame));
               Kernel.getWorker().resume();
               ConnectionsHandler.resume();
               if(Kernel.beingInReconection && !this._reconnectMsgSend)
               {
                  this._reconnectMsgSend = true;
                  ConnectionsHandler.getConnection().send(new CharacterSelectedForceReadyMessage());
               }
               if(InterClientManager.getInstance().flashKey && (!PlayerManager.getInstance() || PlayerManager.getInstance().server.id != 129 && PlayerManager.getInstance().server.id != 130))
               {
                  flashKeyMsg = new ClientKeyMessage();
                  flashKeyMsg.initClientKeyMessage(InterClientManager.getInstance().flashKey);
                  ConnectionsHandler.getConnection().send(flashKeyMsg);
               }
               if(this._cssmsg != null)
               {
                  PlayedCharacterManager.getInstance().infos = this._cssmsg.infos;
                  DataStoreType.CHARACTER_ID = this._cssmsg.infos.id.toString();
               }
               Kernel.getWorker().removeFrame(this);
               if(XmlConfig.getInstance().getBooleanEntry(""config.dev.mode""))
               {
                  ModuleDebugManager.display(XmlConfig.getInstance().getBooleanEntry(""config.dev.auto.display.controler""));
                  Console.getInstance().display(!XmlConfig.getInstance().getBooleanEntry(""config.dev.auto.display.eventUtil""));
                  ConsoleLUA.getInstance().display(!XmlConfig.getInstance().getBooleanEntry(""config.dev.auto.display.luaUtil""));
                  if(XmlConfig.getInstance().getBooleanEntry(""config.dev.auto.display.fpsManager""))
                  {
                     FpsManager.getInstance().display();
                     fpsManagerState = XmlConfig.getInstance().getEntry(""config.dev.auto.display.fpsManager.state"");
                     if(fpsManagerState)
                     {
                        for(i = 0; i < fpsManagerState; i++)
                        {
                           FpsManager.getInstance().changeState();
                        }
                     }
                  }
               }
               else
               {
                  Console.logChatMessagesOnly = true;
                  Console.getInstance().activate();
               }
               this._kernel.processCallback(HookList.GameStart);
               Kernel.getWorker().addFrame(new ServerTransferFrame());
               gccrmsg = new GameContextCreateRequestMessage();
               ConnectionsHandler.getConnection().send(gccrmsg);
               soundApi = new SoundApi();
               soundApi.stopIntroMusic();
               Shortcut.loadSavedData();
               devMode = LangManager.getInstance().getEntry(""config.dev.mode"") == ""true"";
               if(devMode)
               {
                  luaPlayer = ScriptsManager.getInstance().getPlayer(ScriptsManager.LUA_PLAYER) as LuaPlayer;
                  if(!luaPlayer)
                  {
                     luaPlayer = new LuaPlayer();
                     ScriptsManager.getInstance().addPlayer(ScriptsManager.LUA_PLAYER,luaPlayer);
                     ScriptsManager.getInstance().addPlayerApi(luaPlayer,""EntityApi"",new EntityApi());
                     ScriptsManager.getInstance().addPlayerApi(luaPlayer,""SeqApi"",new ScriptSequenceApi());
                     ScriptsManager.getInstance().addPlayerApi(luaPlayer,""CameraApi"",new CameraApi());
                  }
               }
               if(BuildInfos.BUILD_TYPE != BuildTypeEnum.DEBUG)
               {
                  if(OptionManager.getOptionManager(""dofus"").getOption(""optimizeMultiAccount""))
                  {
                     if(InterClientManager.isMaster())
                     {
                        new DataApi().initStaticCartographyData();
                     }
                  }
                  else
                  {
                     new DataApi().initStaticCartographyData();
                  }
               }
               now = new Date().time;
               delta = now - this._loadingStart;
               if(delta > this.LOADING_TIMEOUT)
               {
                  tag = {};
                  tag.duration = uint(delta / 1000);
                  _log.warn(""Client took too long to load ("" + tag.duration + ""s), reporting."");
                  DofusErrorHandler.captureMessage(""Client loading timeout."",tag,RavenClient.WARN);
               }
               ChatServiceManager.getInstance().tryToConnect();
               return true;
            case msg is ConnectionResumedMessage:
               return true;
            case msg is CharacterSelectedErrorMessage:
               csemsg = msg as CharacterSelectedErrorMessage;
               this._kernel.processCallback(HookList.CharacterImpossibleSelection,this._requestedCharacterId);
               this._requestedCharacterId = 0;
               return true;
            case msg is BasicTimeMessage:
               btmsg = msg as BasicTimeMessage;
               date = new Date();
               TimeManager.getInstance().serverTimeLag = btmsg.timestamp + btmsg.timezoneOffset * 60 * 1000 - date.getTime();
               TimeManager.getInstance().serverUtcTimeLag = btmsg.timestamp - date.getTime();
               TimeManager.getInstance().timezoneOffset = btmsg.timezoneOffset * 60 * 1000;
               TimeManager.getInstance().dofusTimeYearLag = -1370;
               return true;
            case msg is StartupActionsListMessage:
               salm = msg as StartupActionsListMessage;
               this._giftList = [];
               for each(gift in salm.actions)
               {
                  _items = [];
                  for each(item in gift.items)
                  {
                     iw = ItemWrapper.create(0,0,item.objectGID,item.quantity,item.effects,false);
                     _items.push(iw);
                  }
                  oj = {
                     ""uid"":gift.uid,
                     ""title"":gift.title,
                     ""text"":gift.text,
                     ""items"":_items
                  };
                  this._giftList.push(oj);
               }
               if(this._giftList.length)
               {
                  this._charaListMinusDeadPeople = [];
                  for each(perso in this._charactersList)
                  {
                     if(!perso.deathState || perso.deathState == 0)
                     {
                        this._charaListMinusDeadPeople.push(perso);
                     }
                  }
                  if(!Berilia.getInstance().getUi(""characterSelection""))
                  {
                     this._kernel.processCallback(HookList.CharacterSelectionStart,this._charactersList);
                  }
                  else
                  {
                     this._kernel.processCallback(HookList.CharactersListUpdated,this._charactersList);
                  }
               }
               else
               {
                  Kernel.getWorker().removeFrame(this);
                  _log.warn(""Empty Gift List Received"");
               }
               return true;
            case msg is GiftAssignRequestAction:
               gar = msg as GiftAssignRequestAction;
               sao = new StartupActionsObjetAttributionMessage();
               sao.initStartupActionsObjetAttributionMessage(gar.giftId,gar.characterId);
               ConnectionsHandler.getConnection().send(sao);
               return true;
            case msg is StartupActionFinishedMessage:
               safm = msg as StartupActionFinishedMessage;
               indexToDelete = -1;
               for each(giftAction in this._giftList)
               {
                  if(giftAction.uid == safm.actionId)
                  {
                     indexToDelete = this._giftList.indexOf(giftAction);
                     break;
                  }
               }
               if(indexToDelete > -1)
               {
                  this._giftList.splice(indexToDelete,1);
                  KernelEventsManager.getInstance().processCallback(HookList.GiftAssigned,safm.actionId);
               }
               return true;
            case msg is ConsoleCommandsListMessage:
               cclMsg = msg as ConsoleCommandsListMessage;
               for(cmdIndex = 0; cmdIndex < cclMsg.aliases.length; cmdIndex++)
               {
                  new ServerCommand(cclMsg.aliases[cmdIndex],cclMsg.descriptions[cmdIndex]);
               }
               return true;
            case msg is GameRolePlayArenaSwitchToFightServerMessage:
               if(Kernel.getWorker().contains(ServerTransferFrame))
               {
                  return false;
               }
               stf = new ServerTransferFrame();
               Kernel.getWorker().addFrame(stf);
               return stf.process(msg);
               break;
            case msg is PopupWarningClosedMessage:
               KernelEventsManager.getInstance().processCallback(HookList.PopupWarningClosed);
               return true;
            case msg is PopupWarningCloseRequestAction:
               pwcrmsg = new PopupWarningCloseRequestMessage();
               pwcrmsg.initPopupWarningCloseRequestMessage();
               ConnectionsHandler.getConnection().send(pwcrmsg);
               return true;
         }
         return false;
      }
      
      public function pulled() : Boolean
      {
         return true;
      }
      
      private function getCharacterColorsInformations(ctrci:*) : Vector.<int>
      {
         var uIndexedColor:Number = NaN;
         var uIndex:int = 0;
         var uColor:* = 0;
         if(!ctrci || !ctrci.colors)
         {
            return null;
         }
         var charColors:Vector.<int> = new Vector.<int>();
         for(var ic:int = 0; ic < ProtocolConstantsEnum.MAX_PLAYER_COLOR; ic++)
         {
            charColors.push(-1);
         }
         var num:int = ctrci.colors.length;
         for(var i:int = 0; i < num; i++)
         {
            uIndexedColor = ctrci.colors[i];
            uIndex = (uIndexedColor >> 24) - 1;
            uColor = uIndexedColor & 16777215;
            if(uIndex > -1 && uIndex < charColors.length)
            {
               charColors[uIndex] = uColor;
            }
         }
         return charColors;
      }
      
      private function onEscapePopup() : void
      {
         Kernel.getInstance().reset();
      }
      
      private function requestCharactersList() : void
      {
         var clrmsg:CharactersListRequestMessage = new CharactersListRequestMessage();
         if(ConnectionsHandler && ConnectionsHandler.getConnection())
         {
            ConnectionsHandler.getConnection().send(clrmsg);
         }
      }
      
      private function getCharacterToConnect() : BasicCharacterWrapper
      {
         var charToConnect:BasicCharacterWrapper = null;
         var charToConnectSpecificallyId:Number = NaN;
         var ctc:BasicCharacterWrapper = null;
         if((Dofus.getInstance().options && Dofus.getInstance().options.getOption(""autoConnectType"") == 2 || PlayerManager.getInstance().autoConnectOfASpecificCharacterId > -1) && PlayerManager.getInstance().allowAutoConnectCharacter)
         {
            charToConnectSpecificallyId = PlayerManager.getInstance().autoConnectOfASpecificCharacterId;
            if(charToConnectSpecificallyId == -1)
            {
               if(this._charactersList.length <= 0)
               {
                  return null;
               }
               charToConnect = this._charactersList[0];
            }
            else
            {
               for each(ctc in this._charactersList)
               {
                  if(ctc.id == charToConnectSpecificallyId)
                  {
                     charToConnect = ctc;
                     break;
                  }
               }
            }
            return charToConnect;
         }
         return null;
      }
      
      private function launchAutoConnect(charToConnect:BasicCharacterWrapper, server:Server) : void
      {
         var updateInformationDisplayed:String = null;
         var currentVersion:String = null;
         var fakacsa:CharacterSelectionAction = null;
         if(charToConnect && ((!FeatureManager.getInstance().isFeatureWithKeywordEnabled(""server.heroic"") && server.gameTypeId != GameServerTypeEnum.SERVER_TYPE_EPIC || charToConnect.deathState == 0) && !SecureModeManager.getInstance().active && !this.isCharacterWaitingForChange(charToConnect.id) && !PlayerManager.getInstance().wasAlreadyConnected))
         {
            this._openCharsList = false;
            this._kernel.processCallback(HookList.CharactersListUpdated,this._charactersList);
            updateInformationDisplayed = StoreDataManager.getInstance().getData(new DataStoreType(""ComputerModule_Ankama_Connection"",true,DataStoreEnum.LOCATION_LOCAL,DataStoreEnum.BIND_COMPUTER),""updateInformationDisplayed"");
            currentVersion = BuildInfos.VERSION.major.toString() + ""-"" + BuildInfos.VERSION.minor.toString();
            if(updateInformationDisplayed == currentVersion)
            {
               fakacsa = new CharacterSelectionAction();
               fakacsa.btutoriel = false;
               fakacsa.characterId = charToConnect.id;
               this.process(fakacsa);
               PlayerManager.getInstance().allowAutoConnectCharacter = false;
            }
         }
      }
   }
}
",12090,False,2133.1912735646292,median
"/*
Feathers
Copyright 2012-2014 Joshua Tynjala. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.controls
{
	import feathers.core.FeathersControl;
	import feathers.core.PropertyProxy;
	import feathers.core.ToggleGroup;
	import feathers.data.ListCollection;
	import feathers.events.CollectionEventType;
	import feathers.layout.HorizontalLayout;
	import feathers.layout.LayoutBoundsResult;
	import feathers.layout.VerticalLayout;
	import feathers.layout.ViewPortBounds;

	import starling.display.DisplayObject;
	import starling.events.Event;

	/**
	 * Dispatched when the selected tab changes.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @eventType starling.events.Event.CHANGE
	 */
	[Event(name=""change"",type=""starling.events.Event"")]

	[DefaultProperty(""dataProvider"")]
	/**
	 * A line of tabs (vertical or horizontal), where one may be selected at a
	 * time.
	 *
	 * <p>The following example sets the data provider, selects the second tab,
	 * and listens for when the selection changes:</p>
	 *
	 * <listing version=""3.0"">
	 * var tabs:TabBar = new TabBar();
	 * tabs.dataProvider = new ListCollection(
	 * [
	 *     { label: ""One"" },
	 *     { label: ""Two"" },
	 *     { label: ""Three"" },
	 * ]);
	 * tabs.selectedIndex = 1;
	 * tabs.addEventListener( Event.CHANGE, tabs_changeHandler );
	 * this.addChild( tabs );</listing>
	 *
	 * @see http://wiki.starling-framework.org/feathers/tab-bar
	 */
	public class TabBar extends FeathersControl
	{
		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_TAB_FACTORY:String = ""tabFactory"";

		/**
		 * @private
		 */
		protected static const NOT_PENDING_INDEX:int = -2;

		/**
		 * @private
		 */
		private static const DEFAULT_TAB_FIELDS:Vector.<String> = new <String>
		[
			""defaultIcon"",
			""upIcon"",
			""downIcon"",
			""hoverIcon"",
			""disabledIcon"",
			""defaultSelectedIcon"",
			""selectedUpIcon"",
			""selectedDownIcon"",
			""selectedHoverIcon"",
			""selectedDisabledIcon""
		];

		/**
		 * The tabs are displayed in order from left to right.
		 *
		 * @see #direction
		 */
		public static const DIRECTION_HORIZONTAL:String = ""horizontal"";

		/**
		 * The tabs are displayed in order from top to bottom.
		 *
		 * @see #direction
		 */
		public static const DIRECTION_VERTICAL:String = ""vertical"";

		/**
		 * The tabs will be aligned horizontally to the left edge of the tab
		 * bar.
		 *
		 * @see #horizontalAlign
		 */
		public static const HORIZONTAL_ALIGN_LEFT:String = ""left"";

		/**
		 * The tabs will be aligned horizontally to the center of the tab bar.
		 *
		 * @see #horizontalAlign
		 */
		public static const HORIZONTAL_ALIGN_CENTER:String = ""center"";

		/**
		 * The tabs will be aligned horizontally to the right edge of the tab
		 * bar.
		 *
		 * @see #horizontalAlign
		 */
		public static const HORIZONTAL_ALIGN_RIGHT:String = ""right"";

		/**
		 * If the direction is vertical, each tab will fill the entire width of
		 * the tab bar, and if the direction is horizontal, the alignment will
		 * behave the same as <code>HORIZONTAL_ALIGN_LEFT</code>.
		 *
		 * @see #horizontalAlign
		 * @see #direction
		 */
		public static const HORIZONTAL_ALIGN_JUSTIFY:String = ""justify"";

		/**
		 * The tabs will be aligned vertically to the top edge of the tab bar.
		 */
		public static const VERTICAL_ALIGN_TOP:String = ""top"";

		/**
		 * The tabs will be aligned vertically to the middle of the tab bar.
		 *
		 * @see #verticalAlign
		 */
		public static const VERTICAL_ALIGN_MIDDLE:String = ""middle"";

		/**
		 * The tabs will be aligned vertically to the bottom edge of the tab
		 * bar.
		 *
		 * @see #verticalAlign
		 */
		public static const VERTICAL_ALIGN_BOTTOM:String = ""bottom"";

		/**
		 * If the direction is horizontal, each tab will fill the entire height
		 * of the tab bar. If the direction is vertical, the alignment will
		 * behave the same as <code>VERTICAL_ALIGN_TOP</code>.
		 *
		 * @see #verticalAlign
		 * @see #direction
		 */
		public static const VERTICAL_ALIGN_JUSTIFY:String = ""justify"";

		/**
		 * The default value added to the <code>nameList</code> of the tabs.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_TAB:String = ""feathers-tab-bar-tab"";

		/**
		 * @private
		 */
		protected static function defaultTabFactory():Button
		{
			return new Button();
		}

		/**
		 * Constructor.
		 */
		public function TabBar()
		{
		}

		/**
		 * The value added to the <code>nameList</code> of the tabs. This
		 * variable is <code>protected</code> so that sub-classes can customize
		 * the tab name in their constructors instead of using the default
		 * name defined by <code>DEFAULT_CHILD_NAME_TAB</code>.
		 *
		 * <p>To customize the tab name without subclassing, see
		 * <code>customTabName</code>.</p>
		 *
		 * @see #customTabName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var tabName:String = DEFAULT_CHILD_NAME_TAB;

		/**
		 * The value added to the <code>nameList</code> of the first tab. This
		 * variable is <code>protected</code> so that sub-classes can customize
		 * the first tab name in their constructors instead of using the default
		 * name defined by <code>DEFAULT_CHILD_NAME_TAB</code>.
		 *
		 * <p>To customize the first tab name without subclassing, see
		 * <code>customFirstTabName</code>.</p>
		 *
		 * @see #customFirstTabName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var firstTabName:String = DEFAULT_CHILD_NAME_TAB;

		/**
		 * The value added to the <code>nameList</code> of the last tab. This
		 * variable is <code>protected</code> so that sub-classes can customize
		 * the last tab name in their constructors instead of using the default
		 * name defined by <code>DEFAULT_CHILD_NAME_TAB</code>.
		 *
		 * <p>To customize the last tab name without subclassing, see
		 * <code>customLastTabName</code>.</p>
		 *
		 * @see #customLastTabName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var lastTabName:String = DEFAULT_CHILD_NAME_TAB;

		/**
		 * The toggle group.
		 */
		protected var toggleGroup:ToggleGroup;

		/**
		 * @private
		 */
		protected var activeFirstTab:Button;

		/**
		 * @private
		 */
		protected var inactiveFirstTab:Button;

		/**
		 * @private
		 */
		protected var activeLastTab:Button;

		/**
		 * @private
		 */
		protected var inactiveLastTab:Button;

		/**
		 * @private
		 */
		protected var _layoutItems:Vector.<DisplayObject> = new <DisplayObject>[];

		/**
		 * @private
		 */
		protected var activeTabs:Vector.<Button> = new <Button>[];

		/**
		 * @private
		 */
		protected var inactiveTabs:Vector.<Button> = new <Button>[];

		/**
		 * @private
		 */
		protected var _dataProvider:ListCollection;

		/**
		 * The collection of data to be displayed with tabs. The default
		 * <em>tab initializer</em> interprets this data to customize the tabs
		 * with various fields available to buttons, including the following:
		 *
		 * <ul>
		 *     <li>label</li>
		 *     <li>defaultIcon</li>
		 *     <li>upIcon</li>
		 *     <li>downIcon</li>
		 *     <li>hoverIcon</li>
		 *     <li>disabledIcon</li>
		 *     <li>defaultSelectedIcon</li>
		 *     <li>selectedUpIcon</li>
		 *     <li>selectedDownIcon</li>
		 *     <li>selectedHoverIcon</li>
		 *     <li>selectedDisabledIcon</li>
		 * </ul>
		 *
		 * <p>The following example passes in a data provider:</p>
		 *
		 * <listing version=""3.0"">
		 * list.dataProvider = new ListCollection(
		 * [
		 *     { label: ""General"", defaultIcon: new Image( generalTexture ) },
		 *     { label: ""Security"", defaultIcon: new Image( securityTexture ) },
		 *     { label: ""Advanced"", defaultIcon: new Image( advancedTexture ) },
		 * ]);</listing>
		 *
		 * @default null
		 *
		 * @see #tabInitializer
		 */
		public function get dataProvider():ListCollection
		{
			return this._dataProvider;
		}

		/**
		 * @private
		 */
		public function set dataProvider(value:ListCollection):void
		{
			if(this._dataProvider == value)
			{
				return;
			}
			var oldSelectedIndex:int = this.selectedIndex;
			var oldSelectedItem:Object = this.selectedItem;
			if(this._dataProvider)
			{
				this._dataProvider.removeEventListener(CollectionEventType.ADD_ITEM, dataProvider_addItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.REMOVE_ITEM, dataProvider_removeItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.REPLACE_ITEM, dataProvider_replaceItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.UPDATE_ITEM, dataProvider_updateItemHandler);
				this._dataProvider.removeEventListener(CollectionEventType.RESET, dataProvider_resetHandler);
			}
			this._dataProvider = value;
			if(this._dataProvider)
			{
				this._dataProvider.addEventListener(CollectionEventType.ADD_ITEM, dataProvider_addItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.REMOVE_ITEM, dataProvider_removeItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.REPLACE_ITEM, dataProvider_replaceItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.UPDATE_ITEM, dataProvider_updateItemHandler);
				this._dataProvider.addEventListener(CollectionEventType.RESET, dataProvider_resetHandler);
			}
			if(!this._dataProvider || this._dataProvider.length == 0)
			{
				this.selectedIndex = -1;
			}
			else
			{
				this.selectedIndex = 0;
			}
			//this ensures that Event.CHANGE will dispatch for selectedItem
			//changing, even if selectedIndex has not changed.
			if(this.selectedIndex == oldSelectedIndex && this.selectedItem != oldSelectedItem)
			{
				this.dispatchEventWith(Event.CHANGE);
			}
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var verticalLayout:VerticalLayout;

		/**
		 * @private
		 */
		protected var horizontalLayout:HorizontalLayout;

		/**
		 * @private
		 */
		protected var _viewPortBounds:ViewPortBounds = new ViewPortBounds();

		/**
		 * @private
		 */
		protected var _layoutResult:LayoutBoundsResult = new LayoutBoundsResult();

		/**
		 * @private
		 */
		protected var _direction:String = DIRECTION_HORIZONTAL;

		[Inspectable(type=""String"",enumeration=""horizontal,vertical"")]
		/**
		 * The tab bar layout is either vertical or horizontal.
		 *
		 * <p>In the following example, the tab bar's direction is set to
		 * vertical:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.direction = TabBar.DIRECTION_VERTICAL;</listing>
		 *
		 * @default TabBar.DIRECTION_HORIZONTAL
		 *
		 * @see #DIRECTION_HORIZONTAL
		 * @see #DIRECTION_VERTICAL
		 */
		public function get direction():String
		{
			return this._direction;
		}

		/**
		 * @private
		 */
		public function set direction(value:String):void
		{
			if(this._direction == value)
			{
				return;
			}
			this._direction = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _horizontalAlign:String = HORIZONTAL_ALIGN_JUSTIFY;

		[Inspectable(type=""String"",enumeration=""left,center,right,justify"")]
		/**
		 * Determines how the tabs are horizontally aligned within the bounds
		 * of the tab bar (on the x-axis).
		 *
		 * <p>The following example aligns the tabs to the left:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.horizontalAlign = TabBar.HORIZONTAL_ALIGN_LEFT;</listing>
		 *
		 * @default TabBar.HORIZONTAL_ALIGN_JUSTIFY
		 *
		 * @see #HORIZONTAL_ALIGN_LEFT
		 * @see #HORIZONTAL_ALIGN_CENTER
		 * @see #HORIZONTAL_ALIGN_RIGHT
		 * @see #HORIZONTAL_ALIGN_JUSTIFY
		 */
		public function get horizontalAlign():String
		{
			return this._horizontalAlign;
		}

		/**
		 * @private
		 */
		public function set horizontalAlign(value:String):void
		{
			if(this._horizontalAlign == value)
			{
				return;
			}
			this._horizontalAlign = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _verticalAlign:String = VERTICAL_ALIGN_JUSTIFY;

		[Inspectable(type=""String"",enumeration=""top,middle,bottom,justify"")]
		/**
		 * Determines how the tabs are vertically aligned within the bounds
		 * of the tab bar (on the y-axis).
		 *
		 * <p>The following example aligns the tabs to the top:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.verticalAlign = TabBar.VERTICAL_ALIGN_TOP;</listing>
		 *
		 * @default TabBar.VERTICAL_ALIGN_JUSTIFY
		 *
		 * @see #VERTICAL_ALIGN_TOP
		 * @see #VERTICAL_ALIGN_MIDDLE
		 * @see #VERTICAL_ALIGN_RIGHT
		 * @see #VERTICAL_ALIGN_JUSTIFY
		 */
		public function get verticalAlign():String
		{
			return this._verticalAlign;
		}

		/**
		 * @private
		 */
		public function set verticalAlign(value:String):void
		{
			if(this._verticalAlign == value)
			{
				return;
			}
			this._verticalAlign = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _distributeTabSizes:Boolean = true;

		/**
		 * If <code>true</code>, the tabs will be equally sized in the direction
		 * of the layout. In other words, if the tab bar is horizontal, each tab
		 * will have the same width, and if the tab bar is vertical, each tab
		 * will have the same height. If <code>false</code>, the tabs will be
		 * sized to their ideal dimensions.
		 *
		 * <p>The following example aligns the tabs to the middle without distributing them:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.direction = TabBar.DIRECTION_VERTICAL;
		 * tabs.verticalAlign = TabBar.VERTICAL_ALIGN_MIDDLE;
		 * tabs.distributeTabSizes = false;</listing>
		 *
		 * @default true
		 */
		public function get distributeTabSizes():Boolean
		{
			return this._distributeTabSizes;
		}

		/**
		 * @private
		 */
		public function set distributeTabSizes(value:Boolean):void
		{
			if(this._distributeTabSizes == value)
			{
				return;
			}
			this._distributeTabSizes = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _gap:Number = 0;

		/**
		 * Space, in pixels, between tabs.
		 *
		 * <p>In the following example, the tab bar's gap is set to 20 pixels:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.gap = 20;</listing>
		 *
		 * @default 0
		 */
		public function get gap():Number
		{
			return this._gap;
		}

		/**
		 * @private
		 */
		public function set gap(value:Number):void
		{
			if(this._gap == value)
			{
				return;
			}
			this._gap = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _firstGap:Number = NaN;

		/**
		 * Space, in pixels, between the first two tabs. If <code>NaN</code>,
		 * the default <code>gap</code> property will be used.
		 *
		 * <p>The following example sets the gap between the first and second
		 * tab to a different value than the standard gap:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.firstGap = 30;
		 * tabs.gap = 20;</listing>
		 *
		 * @default NaN
		 *
		 * @see #gap
		 * @see #lastGap
		 */
		public function get firstGap():Number
		{
			return this._firstGap;
		}

		/**
		 * @private
		 */
		public function set firstGap(value:Number):void
		{
			if(this._firstGap == value)
			{
				return;
			}
			this._firstGap = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _lastGap:Number = NaN;

		/**
		 * Space, in pixels, between the last two tabs. If <code>NaN</code>,
		 * the default <code>gap</code> property will be used.
		 *
		 * <p>The following example sets the gap between the last and next to last
		 * tab to a different value than the standard gap:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.lastGap = 30;
		 * tabs.gap = 20;</listing>
		 *
		 * @default NaN
		 *
		 * @see #gap
		 * @see #firstGap
		 */
		public function get lastGap():Number
		{
			return this._lastGap;
		}

		/**
		 * @private
		 */
		public function set lastGap(value:Number):void
		{
			if(this._lastGap == value)
			{
				return;
			}
			this._lastGap = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * Quickly sets all padding properties to the same value. The
		 * <code>padding</code> getter always returns the value of
		 * <code>paddingTop</code>, but the other padding values may be
		 * different.
		 *
		 * <p>In the following example, the padding of all sides of the tab bar
		 * is set to 20 pixels:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.padding = 20;</listing>
		 *
		 * @default 0
		 *
		 * @see #paddingTop
		 * @see #paddingRight
		 * @see #paddingBottom
		 * @see #paddingLeft
		 */
		public function get padding():Number
		{
			return this._paddingTop;
		}

		/**
		 * @private
		 */
		public function set padding(value:Number):void
		{
			this.paddingTop = value;
			this.paddingRight = value;
			this.paddingBottom = value;
			this.paddingLeft = value;
		}

		/**
		 * @private
		 */
		protected var _paddingTop:Number = 0;

		/**
		 * The minimum space, in pixels, between the tab bar's top edge and the
		 * tabs.
		 *
		 * <p>In the following example, the padding on the top edge of the
		 * tab bar is set to 20 pixels:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.paddingTop = 20;</listing>
		 *
		 * @default 0
		 */
		public function get paddingTop():Number
		{
			return this._paddingTop;
		}

		/**
		 * @private
		 */
		public function set paddingTop(value:Number):void
		{
			if(this._paddingTop == value)
			{
				return;
			}
			this._paddingTop = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _paddingRight:Number = 0;

		/**
		 * The minimum space, in pixels, between the tab bar's right edge and
		 * the tabs.
		 *
		 * <p>In the following example, the padding on the right edge of the
		 * tab bar is set to 20 pixels:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.paddingRight = 20;</listing>
		 *
		 * @default 0
		 */
		public function get paddingRight():Number
		{
			return this._paddingRight;
		}

		/**
		 * @private
		 */
		public function set paddingRight(value:Number):void
		{
			if(this._paddingRight == value)
			{
				return;
			}
			this._paddingRight = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _paddingBottom:Number = 0;

		/**
		 * The minimum space, in pixels, between the tab bar's bottom edge and
		 * the tabs.
		 *
		 * <p>In the following example, the padding on the bottom edge of the
		 * tab bar is set to 20 pixels:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.paddingBottom = 20;</listing>
		 *
		 * @default 0
		 */
		public function get paddingBottom():Number
		{
			return this._paddingBottom;
		}

		/**
		 * @private
		 */
		public function set paddingBottom(value:Number):void
		{
			if(this._paddingBottom == value)
			{
				return;
			}
			this._paddingBottom = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _paddingLeft:Number = 0;

		/**
		 * The minimum space, in pixels, between the tab bar's left edge and the
		 * tabs.
		 *
		 * <p>In the following example, the padding on the left edge of the
		 * tab bar is set to 20 pixels:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.paddingLeft = 20;</listing>
		 *
		 * @default 0
		 */
		public function get paddingLeft():Number
		{
			return this._paddingLeft;
		}

		/**
		 * @private
		 */
		public function set paddingLeft(value:Number):void
		{
			if(this._paddingLeft == value)
			{
				return;
			}
			this._paddingLeft = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _tabFactory:Function = defaultTabFactory;

		/**
		 * Creates a new tab. A tab must be an instance of <code>Button</code>.
		 * This factory can be used to change properties on the tabs when they
		 * are first created. For instance, if you are skinning Feathers
		 * components without a theme, you might use this factory to set skins
		 * and other styles on a tab.
		 *
		 * <p>This function is expected to have the following signature:</p>
		 *
		 * <pre>function():Button</pre>
		 *
		 * <p>In the following example, a custom tab factory is passed to the
		 * tab bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.tabFactory = function():Button
		 * {
		 *     var tab:Button = new Button();
		 *     tab.defaultSkin = new Image( upTexture );
		 *     tab.defaultSelectedSkin = new Image( selectedTexture );
		 *     tab.downSkin = new Image( downTexture );
		 *     return tab;
		 * };</listing>
		 *
		 * @default null
		 *
		 * @see feathers.controls.Button
		 * @see #firstTabFactory
		 * @see #lastTabFactory
		 */
		public function get tabFactory():Function
		{
			return this._tabFactory;
		}

		/**
		 * @private
		 */
		public function set tabFactory(value:Function):void
		{
			if(this._tabFactory == value)
			{
				return;
			}
			this._tabFactory = value;
			this.invalidate(INVALIDATION_FLAG_TAB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _firstTabFactory:Function;

		/**
		 * Creates a new first tab. If the <code>firstTabFactory</code> is
		 * <code>null</code>, then the tab bar will use the <code>tabFactory</code>.
		 * The first tab must be an instance of <code>Button</code>. This
		 * factory can be used to change properties on the first tab when it
		 * is first created. For instance, if you are skinning Feathers
		 * components without a theme, you might use this factory to set skins
		 * and other styles on the first tab.
		 *
		 * <p>This function is expected to have the following signature:</p>
		 *
		 * <pre>function():Button</pre>
		 *
		 * <p>In the following example, a custom first tab factory is passed to the
		 * tab bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.firstTabFactory = function():Button
		 * {
		 *     var tab:Button = new Button();
		 *     tab.defaultSkin = new Image( upTexture );
		 *     tab.defaultSelectedSkin = new Image( selectedTexture );
		 *     tab.downSkin = new Image( downTexture );
		 *     return tab;
		 * };</listing>
		 *
		 * @default null
		 *
		 * @see feathers.controls.Button
		 * @see #tabFactory
		 * @see #lastTabFactory
		 */
		public function get firstTabFactory():Function
		{
			return this._firstTabFactory;
		}

		/**
		 * @private
		 */
		public function set firstTabFactory(value:Function):void
		{
			if(this._firstTabFactory == value)
			{
				return;
			}
			this._firstTabFactory = value;
			this.invalidate(INVALIDATION_FLAG_TAB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _lastTabFactory:Function;

		/**
		 * Creates a new last tab. If the <code>lastTabFactory</code> is
		 * <code>null</code>, then the tab bar will use the <code>tabFactory</code>.
		 * The last tab must be an instance of <code>Button</code>. This
		 * factory can be used to change properties on the last tab when it
		 * is first created. For instance, if you are skinning Feathers
		 * components without a theme, you might use this factory to set skins
		 * and other styles on the last tab.
		 *
		 * <p>This function is expected to have the following signature:</p>
		 *
		 * <pre>function():Button</pre>
		 *
		 * <p>In the following example, a custom last tab factory is passed to the
		 * tab bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.lastTabFactory = function():Button
		 * {
		 *     var tab:Button = new Button();
		 *     tab.defaultSkin = new Image( upTexture );
		 *     tab.defaultSelectedSkin = new Image( selectedTexture );
		 *     tab.downSkin = new Image( downTexture );
		 *     return tab;
		 * };</listing>
		 *
		 * @default null
		 *
		 * @see feathers.controls.Button
		 * @see #tabFactory
		 * @see #firstTabFactory
		 */
		public function get lastTabFactory():Function
		{
			return this._lastTabFactory;
		}

		/**
		 * @private
		 */
		public function set lastTabFactory(value:Function):void
		{
			if(this._lastTabFactory == value)
			{
				return;
			}
			this._lastTabFactory = value;
			this.invalidate(INVALIDATION_FLAG_TAB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _tabInitializer:Function = defaultTabInitializer;

		/**
		 * Modifies the properties of an individual tab, using an item from the
		 * data provider. The default initializer will set the tab's label and
		 * icons. A custom tab initializer can be provided to update additional
		 * properties or to use different field names in the data provider.
		 *
		 * <p>This function is expected to have the following signature:</p>
		 * <pre>function( tab:Button, item:Object ):void</pre>
		 *
		 * <p>In the following example, a custom tab initializer is passed to the
		 * tab bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.tabInitializer = function( tab:Button, item:Object ):void
		 * {
		 *     tab.label = item.text;
		 *     tab.defaultIcon = item.icon;
		 * };</listing>
		 *
		 * @see #dataProvider
		 */
		public function get tabInitializer():Function
		{
			return this._tabInitializer;
		}

		/**
		 * @private
		 */
		public function set tabInitializer(value:Function):void
		{
			if(this._tabInitializer == value)
			{
				return;
			}
			this._tabInitializer = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _ignoreSelectionChanges:Boolean = false;

		/**
		 * @private
		 */
		protected var _pendingSelectedIndex:int = NOT_PENDING_INDEX;

		/**
		 * The index of the currently selected tab. Returns -1 if no tab is
		 * selected.
		 *
		 * <p>In the following example, the tab bar's selected index is changed:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.selectedIndex = 2;</listing>
		 *
		 * <p>The following example listens for when selection changes and
		 * requests the selected index:</p>
		 *
		 * <listing version=""3.0"">
		 * function tabs_changeHandler( event:Event ):void
		 * {
		 *     var tabs:TabBar = TabBar( event.currentTarget );
		 *     var index:int = tabs.selectedIndex;
		 *
		 * }
		 * tabs.addEventListener( Event.CHANGE, tabs_changeHandler );</listing>
		 * 
		 * @default -1
		 * 
		 * @see #selectedItem
		 */
		public function get selectedIndex():int
		{
			if(this._pendingSelectedIndex != NOT_PENDING_INDEX)
			{
				return this._pendingSelectedIndex;
			}
			if(!this.toggleGroup)
			{
				return -1;
			}
			return this.toggleGroup.selectedIndex;
		}

		/**
		 * @private
		 */
		public function set selectedIndex(value:int):void
		{
			if(this._pendingSelectedIndex == value ||
				(this._pendingSelectedIndex == NOT_PENDING_INDEX && this.toggleGroup && this.toggleGroup.selectedIndex == value))
			{
				return;
			}
			this._pendingSelectedIndex = value;
			this.invalidate(INVALIDATION_FLAG_SELECTED);
		}

		/**
		 * The currently selected item from the data provider. Returns
		 * <code>null</code> if no item is selected.
		 *
		 * <p>In the following example, the tab bar's selected item is changed:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.selectedItem = tabs.dataProvider.getItemAt(2);</listing>
		 *
		 * <p>The following example listens for when selection changes and
		 * requests the selected item:</p>
		 *
		 * <listing version=""3.0"">
		 * function tabs_changeHandler( event:Event ):void
		 * {
		 *     var tabs:TabBar = TabBar( event.currentTarget );
		 *     var item:Object = tabs.selectedItem;
		 *
		 * }
		 * tabs.addEventListener( Event.CHANGE, tabs_changeHandler );</listing>
		 * 
		 * @default null
		 * 
		 * @see #selectedIndex
		 */
		public function get selectedItem():Object
		{
			const index:int = this.selectedIndex;
			if(!this._dataProvider || index < 0 || index >= this._dataProvider.length)
			{
				return null;
			}
			return this._dataProvider.getItemAt(index);
		}

		/**
		 * @private
		 */
		public function set selectedItem(value:Object):void
		{
			if(!this._dataProvider)
			{
				this.selectedIndex = -1;
				return;
			}
			this.selectedIndex = this._dataProvider.getItemIndex(value);
		}

		/**
		 * @private
		 */
		protected var _customTabName:String;

		/**
		 * A name to add to all tabs in this tab bar. Typically used by a theme
		 * to provide different skins to different tab bars.
		 *
		 * <p>In the following example, a custom tab name is provided to the tab
		 * bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.customTabName = ""my-custom-tab"";</listing>
		 *
		 * <p>In your theme, you can target this sub-component name to provide
		 * different skins than the default style:</p>
		 *
		 * <listing version=""3.0"">
		 * setInitializerForClass( Button, customTabInitializer, ""my-custom-tab"");</listing>
		 *
		 * @default null
		 *
		 * @see #DEFAULT_CHILD_NAME_TAB
		 * @see feathers.core.FeathersControl#nameList
		 * @see feathers.core.DisplayListWatcher
		 */
		public function get customTabName():String
		{
			return this._customTabName;
		}

		/**
		 * @private
		 */
		public function set customTabName(value:String):void
		{
			if(this._customTabName == value)
			{
				return;
			}
			this._customTabName = value;
			this.invalidate(INVALIDATION_FLAG_TAB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customFirstTabName:String;

		/**
		 * A name to add to the first tab in this tab bar. Typically used by a
		 * theme to provide different skins to the first tab.
		 *
		 * <p>In the following example, a custom first tab name is provided to the tab
		 * bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.customFirstTabName = ""my-custom-first-tab"";</listing>
		 *
		 * <p>In your theme, you can target this sub-component name to provide
		 * different skins than the default style:</p>
		 *
		 * <listing version=""3.0"">
		 * setInitializerForClass( Button, customFirstTabInitializer, ""my-custom-first-tab"");</listing>
		 *
		 * @default null
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see feathers.core.DisplayListWatcher
		 */
		public function get customFirstTabName():String
		{
			return this._customFirstTabName;
		}

		/**
		 * @private
		 */
		public function set customFirstTabName(value:String):void
		{
			if(this._customFirstTabName == value)
			{
				return;
			}
			this._customFirstTabName = value;
			this.invalidate(INVALIDATION_FLAG_TAB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customLastTabName:String;

		/**
		 * A name to add to the last tab in this tab bar. Typically used by a
		 * theme to provide different skins to the last tab.
		 *
		 * <p>In the following example, a custom tab name is provided to the tab
		 * bar:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.customLastTabName = ""my-custom-last-tab"";</listing>
		 *
		 * <p>In your theme, you can target this sub-component name to provide
		 * different skins than the default style:</p>
		 *
		 * <listing version=""3.0"">
		 * setInitializerForClass( Button, customLastTabInitializer, ""my-custom-last-tab"");</listing>
		 *
		 * @default null
		 *
		 * @see feathers.core.FeathersControl#nameList
		 * @see feathers.core.DisplayListWatcher
		 */
		public function get customLastTabName():String
		{
			return this._customLastTabName;
		}

		/**
		 * @private
		 */
		public function set customLastTabName(value:String):void
		{
			if(this._customLastTabName == value)
			{
				return;
			}
			this._customLastTabName = value;
			this.invalidate(INVALIDATION_FLAG_TAB_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _tabProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to all of the tab bar's
		 * tabs. These values are shared by each tabs, so values that cannot be
		 * shared (such as display objects that need to be added to the display
		 * list) should be passed to tabs using the <code>tabFactory</code> or
		 * in a theme. The buttons in a tab bar are instances of
		 * <code>feathers.controls.Button</code> that are created by
		 * <code>tabFactory</code>.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb which is in a <code>SimpleScrollBar</code>,
		 * which is in a <code>List</code>, you can use the following syntax:</p>
		 * <pre>list.verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * <p>Setting properties in a <code>tabFactory</code> function instead
		 * of using <code>tabProperties</code> will result in better
		 * performance.</p>
		 *
		 * <p>In the following example, the tab bar's tab properties are updated:</p>
		 *
		 * <listing version=""3.0"">
		 * tabs.tabProperties.iconPosition = Button.ICON_POSITION_RIGHT;</listing>
		 *
		 * @default null
		 *
		 * @see #tabFactory
		 * @see feathers.controls.Button
		 */
		public function get tabProperties():Object
		{
			if(!this._tabProperties)
			{
				this._tabProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._tabProperties;
		}

		/**
		 * @private
		 */
		public function set tabProperties(value:Object):void
		{
			if(this._tabProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._tabProperties)
			{
				this._tabProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._tabProperties = PropertyProxy(value);
			if(this._tabProperties)
			{
				this._tabProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		override public function dispose():void
		{
			this.dataProvider = null;
			super.dispose();
		}

		/**
		 * @private
		 */
		override protected function initialize():void
		{
			this.toggleGroup = new ToggleGroup();
			this.toggleGroup.isSelectionRequired = true;
			this.toggleGroup.addEventListener(Event.CHANGE, toggleGroup_changeHandler);
		}

		/**
		 * @private
		 */
		override protected function draw():void
		{
			const dataInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_DATA);
			const stylesInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STYLES);
			const stateInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STATE);
			const selectionInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SELECTED);
			const tabFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_TAB_FACTORY);
			var sizeInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SIZE);

			if(dataInvalid || tabFactoryInvalid)
			{
				this.refreshTabs(tabFactoryInvalid);
			}

			if(dataInvalid || tabFactoryInvalid || stylesInvalid)
			{
				this.refreshTabStyles();
			}

			if(dataInvalid || tabFactoryInvalid || selectionInvalid)
			{
				this.commitSelection();
			}

			if(dataInvalid || tabFactoryInvalid || stateInvalid)
			{
				this.commitEnabled();
			}

			if(stylesInvalid)
			{
				this.refreshLayoutStyles();
			}

			this.layoutTabs();
		}

		/**
		 * @private
		 */
		protected function commitSelection():void
		{
			if(this._pendingSelectedIndex == NOT_PENDING_INDEX || !this.toggleGroup)
			{
				return;
			}
			if(this.toggleGroup.selectedIndex == this._pendingSelectedIndex)
			{
				this._pendingSelectedIndex = NOT_PENDING_INDEX;
				return;
			}

			this.toggleGroup.selectedIndex = this._pendingSelectedIndex;
			this._pendingSelectedIndex = NOT_PENDING_INDEX;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected function commitEnabled():void
		{
			for each(var tab:Button in this.activeTabs)
			{
				tab.isEnabled = this._isEnabled;
			}
		}

		/**
		 * @private
		 */
		protected function refreshTabStyles():void
		{
			for each(var tab:Button in this.activeTabs)
			{
				for(var propertyName:String in this._tabProperties)
				{
					var propertyValue:Object = this._tabProperties[propertyName];
					if(tab.hasOwnProperty(propertyName))
					{
						tab[propertyName] = propertyValue;
					}
				}
			}
		}

		/**
		 * @private
		 */
		protected function refreshLayoutStyles():void
		{
			if(this._direction == DIRECTION_VERTICAL)
			{
				if(this.horizontalLayout)
				{
					this.horizontalLayout = null;
				}
				if(!this.verticalLayout)
				{
					this.verticalLayout = new VerticalLayout();
					this.verticalLayout.useVirtualLayout = false;
				}
				this.verticalLayout.distributeHeights = this._distributeTabSizes;
				this.verticalLayout.horizontalAlign = this._horizontalAlign;
				this.verticalLayout.verticalAlign = (this._verticalAlign == VERTICAL_ALIGN_JUSTIFY) ? VERTICAL_ALIGN_TOP : this._verticalAlign;
				this.verticalLayout.gap = this._gap;
				this.verticalLayout.firstGap = this._firstGap;
				this.verticalLayout.lastGap = this._lastGap;
				this.verticalLayout.paddingTop = this._paddingTop;
				this.verticalLayout.paddingRight = this._paddingRight;
				this.verticalLayout.paddingBottom = this._paddingBottom;
				this.verticalLayout.paddingLeft = this._paddingLeft;
			}
			else //horizontal
			{
				if(this.verticalLayout)
				{
					this.verticalLayout = null;
				}
				if(!this.horizontalLayout)
				{
					this.horizontalLayout = new HorizontalLayout();
					this.horizontalLayout.useVirtualLayout = false;
				}
				this.horizontalLayout.distributeWidths = this._distributeTabSizes;
				this.horizontalLayout.horizontalAlign = (this._horizontalAlign == HORIZONTAL_ALIGN_JUSTIFY) ? HORIZONTAL_ALIGN_LEFT : this._horizontalAlign;
				this.horizontalLayout.verticalAlign = this._verticalAlign;
				this.horizontalLayout.gap = this._gap;
				this.horizontalLayout.firstGap = this._firstGap;
				this.horizontalLayout.lastGap = this._lastGap;
				this.horizontalLayout.paddingTop = this._paddingTop;
				this.horizontalLayout.paddingRight = this._paddingRight;
				this.horizontalLayout.paddingBottom = this._paddingBottom;
				this.horizontalLayout.paddingLeft = this._paddingLeft;
			}
		}

		/**
		 * @private
		 */
		protected function defaultTabInitializer(tab:Button, item:Object):void
		{
			if(item is Object)
			{
				if(item.hasOwnProperty(""label""))
				{
					tab.label = item.label;
				}
				else
				{
					tab.label = item.toString();
				}
				for each(var field:String in DEFAULT_TAB_FIELDS)
				{
					if(item.hasOwnProperty(field))
					{
						tab[field] = item[field];
					}
				}
			}
			else
			{
				tab.label = """";
			}

		}

		/**
		 * @private
		 */
		protected function refreshTabs(isFactoryInvalid:Boolean):void
		{
			var oldIgnoreSelectionChanges:Boolean = this._ignoreSelectionChanges;
			this._ignoreSelectionChanges = true;
			var oldSelectedIndex:int = this.toggleGroup.selectedIndex;
			this.toggleGroup.removeAllItems();
			var temp:Vector.<Button> = this.inactiveTabs;
			this.inactiveTabs = this.activeTabs;
			this.activeTabs = temp;
			this.activeTabs.length = 0;
			this._layoutItems.length = 0;
			temp = null;
			if(isFactoryInvalid)
			{
				this.clearInactiveTabs();
			}
			else
			{
				if(this.activeFirstTab)
				{
					this.inactiveTabs.shift();
				}
				this.inactiveFirstTab = this.activeFirstTab;

				if(this.activeLastTab)
				{
					this.inactiveTabs.pop();
				}
				this.inactiveLastTab = this.activeLastTab;
			}
			this.activeFirstTab = null;
			this.activeLastTab = null;

			var pushIndex:int = 0;
			const itemCount:int = this._dataProvider ? this._dataProvider.length : 0;
			const lastItemIndex:int = itemCount - 1;
			for(var i:int = 0; i < itemCount; i++)
			{
				var item:Object = this._dataProvider.getItemAt(i);
				if(i == 0)
				{
					var tab:Button = this.activeFirstTab = this.createFirstTab(item);
				}
				else if(i == lastItemIndex)
				{
					tab = this.activeLastTab = this.createLastTab(item);
				}
				else
				{
					tab = this.createTab(item);
				}
				this.toggleGroup.addItem(tab);
				this.activeTabs[pushIndex] = tab;
				this._layoutItems[pushIndex] = tab;
				pushIndex++;
			}

			this.clearInactiveTabs();
			this._ignoreSelectionChanges = oldIgnoreSelectionChanges;
			if(oldSelectedIndex >= 0)
			{
				var newSelectedIndex:int = this.activeTabs.length - 1;
				if(oldSelectedIndex < newSelectedIndex)
				{
					newSelectedIndex = oldSelectedIndex;
				}
				//removing all items from the ToggleGroup clears the selection,
				//so we need to set it back to the old value (or a new clamped
				//value). we want the change event to dispatch only if the old
				//value and the new value don't match.
				this._ignoreSelectionChanges = oldSelectedIndex == newSelectedIndex;
				this.toggleGroup.selectedIndex = newSelectedIndex;
				this._ignoreSelectionChanges = oldIgnoreSelectionChanges;
			}
		}

		/**
		 * @private
		 */
		protected function clearInactiveTabs():void
		{
			const itemCount:int = this.inactiveTabs.length;
			for(var i:int = 0; i < itemCount; i++)
			{
				var tab:Button = this.inactiveTabs.shift();
				this.destroyTab(tab);
			}

			if(this.inactiveFirstTab)
			{
				this.destroyTab(this.inactiveFirstTab);
				this.inactiveFirstTab = null;
			}

			if(this.inactiveLastTab)
			{
				this.destroyTab(this.inactiveLastTab);
				this.inactiveLastTab = null;
			}
		}

		/**
		 * @private
		 */
		protected function createFirstTab(item:Object):Button
		{
			if(this.inactiveFirstTab)
			{
				var tab:Button = this.inactiveFirstTab;
				this.inactiveFirstTab = null;
			}
			else
			{
				const factory:Function = this._firstTabFactory != null ? this._firstTabFactory : this._tabFactory;
				tab = Button(factory());
				if(this._customFirstTabName)
				{
					tab.styleNameList.add(this._customFirstTabName);
				}
				else if(this._customTabName)
				{
					tab.styleNameList.add(this._customTabName);
				}
				else
				{
					tab.styleNameList.add(this.firstTabName);
				}
				tab.isToggle = true;
				this.addChild(tab);
			}
			this._tabInitializer(tab, item);
			return tab;
		}

		/**
		 * @private
		 */
		protected function createLastTab(item:Object):Button
		{
			if(this.inactiveLastTab)
			{
				var tab:Button = this.inactiveLastTab;
				this.inactiveLastTab = null;
			}
			else
			{
				const factory:Function = this._lastTabFactory != null ? this._lastTabFactory : this._tabFactory;
				tab = Button(factory());
				if(this._customLastTabName)
				{
					tab.styleNameList.add(this._customLastTabName);
				}
				else if(this._customTabName)
				{
					tab.styleNameList.add(this._customTabName);
				}
				else
				{
					tab.styleNameList.add(this.lastTabName);
				}
				tab.isToggle = true;
				this.addChild(tab);
			}
			this._tabInitializer(tab, item);
			return tab;
		}

		/**
		 * @private
		 */
		protected function createTab(item:Object):Button
		{
			if(this.inactiveTabs.length == 0)
			{
				var tab:Button = this._tabFactory();
				if(this._customTabName)
				{
					tab.styleNameList.add(this._customTabName);
				}
				else
				{
					tab.styleNameList.add(this.tabName);
				}
				tab.isToggle = true;
				this.addChild(tab);
			}
			else
			{
				tab = this.inactiveTabs.shift();
			}
			this._tabInitializer(tab, item);
			return tab;
		}

		/**
		 * @private
		 */
		protected function destroyTab(tab:Button):void
		{
			this.toggleGroup.removeItem(tab);
			this.removeChild(tab, true);
		}

		/**
		 * @private
		 */
		protected function layoutTabs():void
		{
			this._viewPortBounds.x = 0;
			this._viewPortBounds.y = 0;
			this._viewPortBounds.scrollX = 0;
			this._viewPortBounds.scrollY = 0;
			this._viewPortBounds.explicitWidth = this.explicitWidth;
			this._viewPortBounds.explicitHeight = this.explicitHeight;
			this._viewPortBounds.minWidth = this._minWidth;
			this._viewPortBounds.minHeight = this._minHeight;
			this._viewPortBounds.maxWidth = this._maxWidth;
			this._viewPortBounds.maxHeight = this._maxHeight;
			if(this.verticalLayout)
			{
				this.verticalLayout.layout(this._layoutItems, this._viewPortBounds, this._layoutResult);
			}
			else if(this.horizontalLayout)
			{
				this.horizontalLayout.layout(this._layoutItems, this._viewPortBounds, this._layoutResult);
			}
			this.setSizeInternal(this._layoutResult.contentWidth, this._layoutResult.contentHeight, false);
		}

		/**
		 * @private
		 */
		protected function childProperties_onChange(proxy:PropertyProxy, name:String):void
		{
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected function toggleGroup_changeHandler(event:Event):void
		{
			if(this._ignoreSelectionChanges || this._pendingSelectedIndex != NOT_PENDING_INDEX)
			{
				return;
			}
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected function dataProvider_addItemHandler(event:Event, index:int):void
		{
			if(this.toggleGroup && this.toggleGroup.selectedIndex >= index)
			{
				//let's keep the same item selected
				this._pendingSelectedIndex = this.toggleGroup.selectedIndex + 1;
				this.invalidate(INVALIDATION_FLAG_SELECTED);
			}
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected function dataProvider_removeItemHandler(event:Event, index:int):void
		{
			if(this.toggleGroup && this.toggleGroup.selectedIndex > index)
			{
				//let's keep the same item selected
				this._pendingSelectedIndex = this.toggleGroup.selectedIndex - 1;
				this.invalidate(INVALIDATION_FLAG_SELECTED);
			}
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected function dataProvider_resetHandler(event:Event):void
		{
			if(this.toggleGroup && this._dataProvider.length > 0)
			{
				//the data provider has changed drastically. we should reset the
				//selection to the first item.
				this._pendingSelectedIndex = 0;
				this.invalidate(INVALIDATION_FLAG_SELECTED);
			}
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected function dataProvider_replaceItemHandler(event:Event, index:int):void
		{
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected function dataProvider_updateItemHandler(event:Event, index:int):void
		{
			this.invalidate(INVALIDATION_FLAG_DATA);
		}
	}
}
",12462,True,2667.6725142082637,median
"/*
* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/

package Box2D.Dynamics
{
	
	import Box2D.Collision.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Dynamics.Controllers.b2Controller;
	import Box2D.Dynamics.Controllers.b2ControllerEdge;
	import Box2D.Dynamics.Joints.*;
	
	/**
	 * The world class manages all physics entities, dynamic simulation,
	 * and asynchronous queries.
	 */
	public class b2World
	{
		
		// m_flags
		public static const e_newFixture:int = 0x0001;
		
		/**
		 * Destruct the world. All physics entities are destroyed and all heap memory is released.
		 */
			
			//~b2World();
		public static const e_locked:int = 0x0002;
		private static var s_timestep2:b2TimeStep = new b2TimeStep();
		static private var s_xf:b2Transform = new b2Transform();
		private static var s_backupA:b2Sweep = new b2Sweep();
		private static var s_backupB:b2Sweep = new b2Sweep();
		private static var s_timestep:b2TimeStep = new b2TimeStep();
		private static var s_queue:Vector.<b2Body> = new Vector.<b2Body>();
		static private var s_jointColor:b2Color = new b2Color(0.5, 0.8, 0.8);
		// This is for debugging the solver.
		static private var m_warmStarting:Boolean;
		// This is for debugging the solver.
		static private var m_continuousPhysics:Boolean;
		public var m_flags:int;
		public var m_contactManager:b2ContactManager = new b2ContactManager();
		public var m_bodyList:b2Body;
		public var m_contactList:b2Contact;
		public var m_contactCount:int;
		public var m_groundBody:b2Body;
		// Find islands, integrate and solve constraints, solve position constraints
		private var s_stack:Vector.<b2Body> = new Vector.<b2Body>();
		// any data outside of a call to Step
		private var m_contactSolver:b2ContactSolver = new b2ContactSolver();
		private var m_island:b2Island = new b2Island();
		private var m_jointList:b2Joint;
		private var m_bodyCount:int;
		private var m_jointCount:int;
		private var m_controllerList:b2Controller;
		private var m_controllerCount:int;
		private var m_gravity:b2Vec2;
		private var m_allowSleep:Boolean;
		private var m_destructionListener:b2DestructionListener;
		private var m_debugDraw:b2DebugDraw;
		// This is used to compute the time step ratio to support a variable time step.
		private var m_inv_dt0:Number;
		
		// Construct a world object.
		/**
		 * @param gravity the world gravity vector.
		 * @param doSleep improve performance by not simulating inactive bodies.
		 */
		public function b2World(gravity:b2Vec2, doSleep:Boolean)
		{
			
			m_destructionListener = null;
			m_debugDraw = null;
			
			m_bodyList = null;
			m_contactList = null;
			m_jointList = null;
			m_controllerList = null;
			
			m_bodyCount = 0;
			m_contactCount = 0;
			m_jointCount = 0;
			m_controllerCount = 0;
			
			m_warmStarting = true;
			m_continuousPhysics = true;
			
			m_allowSleep = doSleep;
			m_gravity = gravity;
			
			m_inv_dt0 = 0.0;
			
			m_contactManager.m_world = this;
			
			var bd:b2BodyDef = new b2BodyDef();
			m_groundBody = CreateBody(bd);
		}
		
		/**
		 * Register a destruction listener.
		 */
		public function SetDestructionListener(listener:b2DestructionListener):void
		{
			m_destructionListener = listener;
		}
		
		/**
		 * Register a contact filter to provide specific control over collision.
		 * Otherwise the default filter is used (b2_defaultFilter).
		 */
		public function SetContactFilter(filter:b2ContactFilter):void
		{
			m_contactManager.m_contactFilter = filter;
		}
		
		/**
		 * Register a contact event listener
		 */
		public function SetContactListener(listener:b2ContactListener):void
		{
			m_contactManager.m_contactListener = listener;
		}
		
		/**
		 * Register a routine for debug drawing. The debug draw functions are called
		 * inside the b2World::Step method, so make sure your renderer is ready to
		 * consume draw commands when you call Step().
		 */
		public function SetDebugDraw(debugDraw:b2DebugDraw):void
		{
			m_debugDraw = debugDraw;
		}
		
		/**
		 * Use the given object as a broadphase.
		 * The old broadphase will not be cleanly emptied.
		 * @warning It is not recommended you call this except immediately after constructing the world.
		 * @warning This function is locked during callbacks.
		 */
		public function SetBroadPhase(broadPhase:IBroadPhase):void
		{
			var oldBroadPhase:IBroadPhase = m_contactManager.m_broadPhase;
			m_contactManager.m_broadPhase = broadPhase;
			for (var b:b2Body = m_bodyList; b; b = b.m_next)
			{
				for (var f:b2Fixture = b.m_fixtureList; f; f = f.m_next)
				{
					f.m_proxy = broadPhase.CreateProxy(oldBroadPhase.GetFatAABB(f.m_proxy), f);
				}
			}
		}
		
		/**
		 * Perform validation of internal data structures.
		 */
		public function Validate():void
		{
			m_contactManager.m_broadPhase.Validate();
		}
		
		/**
		 * Get the number of broad-phase proxies.
		 */
		public function GetProxyCount():int
		{
			return m_contactManager.m_broadPhase.GetProxyCount();
		}
		
		/**
		 * Create a rigid body given a definition. No reference to the definition
		 * is retained.
		 * @warning This function is locked during callbacks.
		 */
		public function CreateBody(def:b2BodyDef):b2Body
		{
			
			//b2Settings.b2Assert(m_lock == false);
			if (IsLocked() == true)
			{
				return null;
			}
			
			//void* mem = m_blockAllocator.Allocate(sizeof(b2Body));
			var b:b2Body = new b2Body(def, this);
			
			// Add to world doubly linked list.
			b.m_prev = null;
			b.m_next = m_bodyList;
			if (m_bodyList)
			{
				m_bodyList.m_prev = b;
			}
			m_bodyList = b;
			++m_bodyCount;
			
			return b;
			
		}
		
		//--------------- Internals Below -------------------
		// Internal yet public to make life easier.
		
		/**
		 * Destroy a rigid body given a definition. No reference to the definition
		 * is retained. This function is locked during callbacks.
		 * @warning This automatically deletes all associated shapes and joints.
		 * @warning This function is locked during callbacks.
		 */
		public function DestroyBody(b:b2Body):void
		{
			
			//b2Settings.b2Assert(m_bodyCount > 0);
			//b2Settings.b2Assert(m_lock == false);
			if (IsLocked() == true)
			{
				return;
			}
			
			// Delete the attached joints.
			var jn:b2JointEdge = b.m_jointList;
			while (jn)
			{
				var jn0:b2JointEdge = jn;
				jn = jn.next;
				
				if (m_destructionListener)
				{
					m_destructionListener.SayGoodbyeJoint(jn0.joint);
				}
				
				DestroyJoint(jn0.joint);
			}
			
			// Detach controllers attached to this body
			var coe:b2ControllerEdge = b.m_controllerList;
			while (coe)
			{
				var coe0:b2ControllerEdge = coe;
				coe = coe.nextController;
				coe0.controller.RemoveBody(b);
			}
			
			// Delete the attached contacts.
			var ce:b2ContactEdge = b.m_contactList;
			while (ce)
			{
				var ce0:b2ContactEdge = ce;
				ce = ce.next;
				m_contactManager.Destroy(ce0.contact);
			}
			b.m_contactList = null;
			
			// Delete the attached fixtures. This destroys broad-phase
			// proxies.
			var f:b2Fixture = b.m_fixtureList;
			while (f)
			{
				var f0:b2Fixture = f;
				f = f.m_next;
				
				if (m_destructionListener)
				{
					m_destructionListener.SayGoodbyeFixture(f0);
				}
				
				f0.DestroyProxy(m_contactManager.m_broadPhase);
				f0.Destroy();
				//f0->~b2Fixture();
				//m_blockAllocator.Free(f0, sizeof(b2Fixture));
				
			}
			b.m_fixtureList = null;
			b.m_fixtureCount = 0;
			
			// Remove world body list.
			if (b.m_prev)
			{
				b.m_prev.m_next = b.m_next;
			}
			
			if (b.m_next)
			{
				b.m_next.m_prev = b.m_prev;
			}
			
			if (b == m_bodyList)
			{
				m_bodyList = b.m_next;
			}
			
			--m_bodyCount;
			//b->~b2Body();
			//m_blockAllocator.Free(b, sizeof(b2Body));
			
		}
		
		/**
		 * Create a joint to constrain bodies together. No reference to the definition
		 * is retained. This may cause the connected bodies to cease colliding.
		 * @warning This function is locked during callbacks.
		 */
		public function CreateJoint(def:b2JointDef):b2Joint
		{
			
			//b2Settings.b2Assert(m_lock == false);
			
			var j:b2Joint = b2Joint.Create(def, null);
			
			// Connect to the world list.
			j.m_prev = null;
			j.m_next = m_jointList;
			if (m_jointList)
			{
				m_jointList.m_prev = j;
			}
			m_jointList = j;
			++m_jointCount;
			
			// Connect to the bodies' doubly linked lists.
			j.m_edgeA.joint = j;
			j.m_edgeA.other = j.m_bodyB;
			j.m_edgeA.prev = null;
			j.m_edgeA.next = j.m_bodyA.m_jointList;
			if (j.m_bodyA.m_jointList) j.m_bodyA.m_jointList.prev = j.m_edgeA;
			j.m_bodyA.m_jointList = j.m_edgeA;
			
			j.m_edgeB.joint = j;
			j.m_edgeB.other = j.m_bodyA;
			j.m_edgeB.prev = null;
			j.m_edgeB.next = j.m_bodyB.m_jointList;
			if (j.m_bodyB.m_jointList) j.m_bodyB.m_jointList.prev = j.m_edgeB;
			j.m_bodyB.m_jointList = j.m_edgeB;
			
			var bodyA:b2Body = def.bodyA;
			var bodyB:b2Body = def.bodyB;
			
			// If the joint prevents collisions, then flag any contacts for filtering.
			if (def.collideConnected == false)
			{
				var edge:b2ContactEdge = bodyB.GetContactList();
				while (edge)
				{
					if (edge.other == bodyA)
					{
						// Flag the contact for filtering at the next time step (where either
						// body is awake).
						edge.contact.FlagForFiltering();
					}
					
					edge = edge.next;
				}
			}
			
			// Note: creating a joint doesn't wake the bodies.
			
			return j;
			
		}
		
		/**
		 * Destroy a joint. This may cause the connected bodies to begin colliding.
		 * @warning This function is locked during callbacks.
		 */
		public function DestroyJoint(j:b2Joint):void
		{
			
			//b2Settings.b2Assert(m_lock == false);
			
			var collideConnected:Boolean = j.m_collideConnected;
			
			// Remove from the doubly linked list.
			if (j.m_prev)
			{
				j.m_prev.m_next = j.m_next;
			}
			
			if (j.m_next)
			{
				j.m_next.m_prev = j.m_prev;
			}
			
			if (j == m_jointList)
			{
				m_jointList = j.m_next;
			}
			
			// Disconnect from island graph.
			var bodyA:b2Body = j.m_bodyA;
			var bodyB:b2Body = j.m_bodyB;
			
			// Wake up connected bodies.
			bodyA.SetAwake(true);
			bodyB.SetAwake(true);
			
			// Remove from body 1.
			if (j.m_edgeA.prev)
			{
				j.m_edgeA.prev.next = j.m_edgeA.next;
			}
			
			if (j.m_edgeA.next)
			{
				j.m_edgeA.next.prev = j.m_edgeA.prev;
			}
			
			if (j.m_edgeA == bodyA.m_jointList)
			{
				bodyA.m_jointList = j.m_edgeA.next;
			}
			
			j.m_edgeA.prev = null;
			j.m_edgeA.next = null;
			
			// Remove from body 2
			if (j.m_edgeB.prev)
			{
				j.m_edgeB.prev.next = j.m_edgeB.next;
			}
			
			if (j.m_edgeB.next)
			{
				j.m_edgeB.next.prev = j.m_edgeB.prev;
			}
			
			if (j.m_edgeB == bodyB.m_jointList)
			{
				bodyB.m_jointList = j.m_edgeB.next;
			}
			
			j.m_edgeB.prev = null;
			j.m_edgeB.next = null;
			
			b2Joint.Destroy(j, null);
			
			//b2Settings.b2Assert(m_jointCount > 0);
			--m_jointCount;
			
			// If the joint prevents collisions, then flag any contacts for filtering.
			if (collideConnected == false)
			{
				var edge:b2ContactEdge = bodyB.GetContactList();
				while (edge)
				{
					if (edge.other == bodyA)
					{
						// Flag the contact for filtering at the next time step (where either
						// body is awake).
						edge.contact.FlagForFiltering();
					}
					
					edge = edge.next;
				}
			}
			
		}
		
		/**
		 * Add a controller to the world list
		 */
		public function AddController(c:b2Controller):b2Controller
		{
			c.m_next = m_controllerList;
			c.m_prev = null;
			m_controllerList = c;
			
			c.m_world = this;
			
			m_controllerCount++;
			
			return c;
		}
		
		public function RemoveController(c:b2Controller):void
		{
			//TODO: Remove bodies from controller
			if (c.m_prev)
				c.m_prev.m_next = c.m_next;
			if (c.m_next)
				c.m_next.m_prev = c.m_prev;
			if (m_controllerList == c)
				m_controllerList = c.m_next;
			
			m_controllerCount--;
		}
		
		public function CreateController(controller:b2Controller):b2Controller
		{
			if (controller.m_world != this)
				throw new Error(""Controller can only be a member of one world"");
			
			controller.m_next = m_controllerList;
			controller.m_prev = null;
			if (m_controllerList)
				m_controllerList.m_prev = controller;
			m_controllerList = controller;
			++m_controllerCount;
			
			controller.m_world = this;
			
			return controller;
		}
		
		public function DestroyController(controller:b2Controller):void
		{
			//b2Settings.b2Assert(m_controllerCount > 0);
			controller.Clear();
			if (controller.m_next)
				controller.m_next.m_prev = controller.m_prev;
			if (controller.m_prev)
				controller.m_prev.m_next = controller.m_next;
			if (controller == m_controllerList)
				m_controllerList = controller.m_next;
			--m_controllerCount;
		}
		
		/**
		 * Enable/disable warm starting. For testing.
		 */
		public function SetWarmStarting(flag:Boolean):void
		{
			m_warmStarting = flag;
		}
		
		/**
		 * Enable/disable continuous physics. For testing.
		 */
		public function SetContinuousPhysics(flag:Boolean):void
		{
			m_continuousPhysics = flag;
		}
		
		/**
		 * Get the number of bodies.
		 */
		public function GetBodyCount():int
		{
			return m_bodyCount;
		}
		
		/**
		 * Get the number of joints.
		 */
		public function GetJointCount():int
		{
			return m_jointCount;
		}
		
		/**
		 * Get the number of contacts (each may have 0 or more contact points).
		 */
		public function GetContactCount():int
		{
			return m_contactCount;
		}
		
		// These two are stored purely for efficiency purposes, they don't maintain
		
		/**
		 * Change the global gravity vector.
		 */
		public function SetGravity(gravity:b2Vec2):void
		{
			m_gravity = gravity;
		}
		
		/**
		 * Get the global gravity vector.
		 */
		public function GetGravity():b2Vec2
		{
			return m_gravity;
		}
		
		/**
		 * The world provides a single static ground body with no collision shapes.
		 * You can use this to simplify the creation of joints and static shapes.
		 */
		public function GetGroundBody():b2Body
		{
			return m_groundBody;
		}
		
		/**
		 * Take a time step. This performs collision detection, integration,
		 * and constraint solution.
		 * @param timeStep the amount of time to simulate, this should not vary.
		 * @param velocityIterations for the velocity constraint solver.
		 * @param positionIterations for the position constraint solver.
		 */
		public function Step(dt:Number, velocityIterations:int, positionIterations:int):void
		{
			if (m_flags & e_newFixture)
			{
				m_contactManager.FindNewContacts();
				m_flags &= ~e_newFixture;
			}
			
			m_flags |= e_locked;
			
			var step:b2TimeStep = s_timestep2;
			step.dt = dt;
			step.velocityIterations = velocityIterations;
			step.positionIterations = positionIterations;
			if (dt > 0.0)
			{
				step.inv_dt = 1.0 / dt;
			}
			else
			{
				step.inv_dt = 0.0;
			}
			
			step.dtRatio = m_inv_dt0 * dt;
			
			step.warmStarting = m_warmStarting;
			
			// Update contacts.
			m_contactManager.Collide();
			
			// Integrate velocities, solve velocity constraints, and integrate positions.
			if (step.dt > 0.0)
			{
				Solve(step);
			}
			
			// Handle TOI events.
			if (m_continuousPhysics && step.dt > 0.0)
			{
				SolveTOI(step);
			}
			
			if (step.dt > 0.0)
			{
				m_inv_dt0 = step.inv_dt;
			}
			m_flags &= ~e_locked;
		}
		
		/**
		 * Call this after you are done with time steps to clear the forces. You normally
		 * call this after each call to Step, unless you are performing sub-steps.
		 */
		public function ClearForces():void
		{
			for (var body:b2Body = m_bodyList; body; body = body.m_next)
			{
				body.m_force.SetZero();
				body.m_torque = 0.0;
			}
		}
		
		/**
		 * Call this to draw shapes and other debug draw data.
		 */
		public function DrawDebugData():void
		{
			
			if (m_debugDraw == null)
			{
				return;
			}
			
			m_debugDraw.m_sprite.graphics.clear();
			
			var flags:uint = m_debugDraw.GetFlags();
			
			var i:int;
			var b:b2Body;
			var f:b2Fixture;
			var s:b2Shape;
			var j:b2Joint;
			var bp:IBroadPhase;
			var invQ:b2Vec2 = new b2Vec2;
			var x1:b2Vec2 = new b2Vec2;
			var x2:b2Vec2 = new b2Vec2;
			var xf:b2Transform;
			var b1:b2AABB = new b2AABB();
			var b2:b2AABB = new b2AABB();
			var vs:Array = [new b2Vec2(), new b2Vec2(), new b2Vec2(), new b2Vec2()];
			
			// Store color here and reuse, to reduce allocations
			var color:b2Color = new b2Color(0, 0, 0);
			
			if (flags & b2DebugDraw.e_shapeBit)
			{
				for (b = m_bodyList; b; b = b.m_next)
				{
					xf = b.m_xf;
					for (f = b.GetFixtureList(); f; f = f.m_next)
					{
						s = f.GetShape();
						if (b.IsActive() == false)
						{
							color.Set(0.5, 0.5, 0.3);
							DrawShape(s, xf, color);
						}
						else if (b.GetType() == b2Body.b2_staticBody)
						{
							color.Set(0.5, 0.9, 0.5);
							DrawShape(s, xf, color);
						}
						else if (b.GetType() == b2Body.b2_kinematicBody)
						{
							color.Set(0.5, 0.5, 0.9);
							DrawShape(s, xf, color);
						}
						else if (b.IsAwake() == false)
						{
							color.Set(0.6, 0.6, 0.6);
							DrawShape(s, xf, color);
						}
						else
						{
							color.Set(0.9, 0.7, 0.7);
							DrawShape(s, xf, color);
						}
					}
				}
			}
			
			if (flags & b2DebugDraw.e_jointBit)
			{
				for (j = m_jointList; j; j = j.m_next)
				{
					DrawJoint(j);
				}
			}
			
			if (flags & b2DebugDraw.e_controllerBit)
			{
				for (var c:b2Controller = m_controllerList; c; c = c.m_next)
				{
					c.Draw(m_debugDraw);
				}
			}
			
			if (flags & b2DebugDraw.e_pairBit)
			{
				color.Set(0.3, 0.9, 0.9);
				for (var contact:b2Contact = m_contactManager.m_contactList; contact; contact = contact.GetNext())
				{
					var fixtureA:b2Fixture = contact.GetFixtureA();
					var fixtureB:b2Fixture = contact.GetFixtureB();
					
					var cA:b2Vec2 = fixtureA.GetAABB().GetCenter();
					var cB:b2Vec2 = fixtureB.GetAABB().GetCenter();
					
					m_debugDraw.DrawSegment(cA, cB, color);
				}
			}
			
			if (flags & b2DebugDraw.e_aabbBit)
			{
				bp = m_contactManager.m_broadPhase;
				
				vs = [new b2Vec2(), new b2Vec2(), new b2Vec2(), new b2Vec2()];
				
				for (b = m_bodyList; b; b = b.GetNext())
				{
					if (b.IsActive() == false)
					{
						continue;
					}
					for (f = b.GetFixtureList(); f; f = f.GetNext())
					{
						var aabb:b2AABB = bp.GetFatAABB(f.m_proxy);
						vs[0].Set(aabb.lowerBound.x, aabb.lowerBound.y);
						vs[1].Set(aabb.upperBound.x, aabb.lowerBound.y);
						vs[2].Set(aabb.upperBound.x, aabb.upperBound.y);
						vs[3].Set(aabb.lowerBound.x, aabb.upperBound.y);
						
						m_debugDraw.DrawPolygon(vs, 4, color);
					}
				}
			}
			
			if (flags & b2DebugDraw.e_centerOfMassBit)
			{
				for (b = m_bodyList; b; b = b.m_next)
				{
					xf = s_xf;
					xf.R = b.m_xf.R;
					xf.position = b.GetWorldCenter();
					m_debugDraw.DrawTransform(xf);
				}
			}
		}
		
		/**
		 * Query the world for all fixtures that potentially overlap the
		 * provided AABB.
		 * @param callback a user implemented callback class. It should match signature
		 * <code>function Callback(fixture:b2Fixture):Boolean</code>
		 * Return true to continue to the next fixture.
		 * @param aabb the query box.
		 */
		public function QueryAABB(callback:Function, aabb:b2AABB):void
		{
			var broadPhase:IBroadPhase = m_contactManager.m_broadPhase;
			
			function WorldQueryWrapper(proxy:*):Boolean
			{
				return callback(broadPhase.GetUserData(proxy));
			}
			
			broadPhase.Query(WorldQueryWrapper, aabb);
		}
		
		/**
		 * Query the world for all fixtures that precisely overlap the
		 * provided transformed shape.
		 * @param callback a user implemented callback class. It should match signature
		 * <code>function Callback(fixture:b2Fixture):Boolean</code>
		 * Return true to continue to the next fixture.
		 * @asonly
		 */
		public function QueryShape(callback:Function, shape:b2Shape, transform:b2Transform = null):void
		{
			if (transform == null)
			{
				transform = new b2Transform();
				transform.SetIdentity();
			}
			var broadPhase:IBroadPhase = m_contactManager.m_broadPhase;
			
			function WorldQueryWrapper(proxy:*):Boolean
			{
				var fixture:b2Fixture = broadPhase.GetUserData(proxy) as b2Fixture
				if (b2Shape.TestOverlap(shape, transform, fixture.GetShape(), fixture.GetBody().GetTransform()))
					return callback(fixture);
				return true;
			}
			
			var aabb:b2AABB = new b2AABB();
			shape.ComputeAABB(aabb, transform);
			broadPhase.Query(WorldQueryWrapper, aabb);
		}
		
		/**
		 * Query the world for all fixtures that contain a point.
		 * @param callback a user implemented callback class. It should match signature
		 * <code>function Callback(fixture:b2Fixture):Boolean</code>
		 * Return true to continue to the next fixture.
		 * @asonly
		 */
		public function QueryPoint(callback:Function, p:b2Vec2):void
		{
			var broadPhase:IBroadPhase = m_contactManager.m_broadPhase;
			
			function WorldQueryWrapper(proxy:*):Boolean
			{
				var fixture:b2Fixture = broadPhase.GetUserData(proxy) as b2Fixture
				if (fixture.TestPoint(p))
					return callback(fixture);
				return true;
			}
			
			// Make a small box.
			var aabb:b2AABB = new b2AABB();
			aabb.lowerBound.Set(p.x - b2Settings.b2_linearSlop, p.y - b2Settings.b2_linearSlop);
			aabb.upperBound.Set(p.x + b2Settings.b2_linearSlop, p.y + b2Settings.b2_linearSlop);
			broadPhase.Query(WorldQueryWrapper, aabb);
		}
		
		/**
		 * Ray-cast the world for all fixtures in the path of the ray. Your callback
		 * Controls whether you get the closest point, any point, or n-points
		 * The ray-cast ignores shapes that contain the starting point
		 * @param callback A callback function which must be of signature:
		 * <code>function Callback(fixture:b2Fixture,    // The fixture hit by the ray
		 * point:b2Vec2,         // The point of initial intersection
		 * normal:b2Vec2,        // The normal vector at the point of intersection
		 * fraction:Number       // The fractional length along the ray of the intersection
		 * ):Number
		 * </code>
		 * Callback should return the new length of the ray as a fraction of the original length.
		 * By returning 0, you immediately terminate.
		 * By returning 1, you continue wiht the original ray.
		 * By returning the current fraction, you proceed to find the closest point.
		 * @param point1 the ray starting point
		 * @param point2 the ray ending point
		 */
		public function RayCast(callback:Function, point1:b2Vec2, point2:b2Vec2):void
		{
			var broadPhase:IBroadPhase = m_contactManager.m_broadPhase;
			var output:b2RayCastOutput = new b2RayCastOutput;
			
			function RayCastWrapper(input:b2RayCastInput, proxy:*):Number
			{
				var userData:* = broadPhase.GetUserData(proxy);
				var fixture:b2Fixture = userData as b2Fixture;
				var hit:Boolean = fixture.RayCast(output, input);
				if (hit)
				{
					var fraction:Number = output.fraction;
					var point:b2Vec2 = new b2Vec2(
						(1.0 - fraction) * point1.x + fraction * point2.x,
						(1.0 - fraction) * point1.y + fraction * point2.y);
					return callback(fixture, point, output.normal, fraction);
				}
				return input.maxFraction;
			}
			
			var input:b2RayCastInput = new b2RayCastInput(point1, point2);
			broadPhase.RayCast(RayCastWrapper, input);
		}
		
		public function RayCastOne(point1:b2Vec2, point2:b2Vec2):b2Fixture
		{
			var result:b2Fixture;
			
			function RayCastOneWrapper(fixture:b2Fixture, point:b2Vec2, normal:b2Vec2, fraction:Number):Number
			{
				result = fixture;
				return fraction;
			}
			
			RayCast(RayCastOneWrapper, point1, point2);
			return result;
		}
		
		public function RayCastAll(point1:b2Vec2, point2:b2Vec2):Vector.<b2Fixture>
		{
			var result:Vector.<b2Fixture> = new Vector.<b2Fixture>();
			
			var RayCastAllWrapper:Function = function (fixture:b2Fixture, point:b2Vec2, normal:b2Vec2, fraction:Number):Number {
				result[result.length] = fixture;
				return 1;
			};
			
			RayCast(RayCastAllWrapper, point1, point2);
			return result;
		}
		
		/**
		 * Get the world body list. With the returned body, use b2Body::GetNext to get
		 * the next body in the world list. A NULL body indicates the end of the list.
		 * @return the head of the world body list.
		 */
		public function GetBodyList():b2Body
		{
			return m_bodyList;
		}
		
		/**
		 * Get the world joint list. With the returned joint, use b2Joint::GetNext to get
		 * the next joint in the world list. A NULL joint indicates the end of the list.
		 * @return the head of the world joint list.
		 */
		public function GetJointList():b2Joint
		{
			return m_jointList;
		}
		
		/**
		 * Get the world contact list. With the returned contact, use b2Contact::GetNext to get
		 * the next contact in the world list. A NULL contact indicates the end of the list.
		 * @return the head of the world contact list.
		 * @warning contacts are
		 */
		public function GetContactList():b2Contact
		{
			return m_contactList;
		}
		
		/**
		 * Is the world locked (in the middle of a time step).
		 */
		public function IsLocked():Boolean
		{
			return (m_flags & e_locked) > 0;
		}
		
		public function Solve(step:b2TimeStep):void
		{
			var b:b2Body;
			
			// Step all controllers
			for (var controller:b2Controller = m_controllerList; controller; controller = controller.m_next)
			{
				controller.Step(step);
			}
			
			// Size the island for the worst case.
			var island:b2Island = m_island;
			island.Initialize(m_bodyCount, m_contactCount, m_jointCount, null, m_contactManager.m_contactListener, m_contactSolver);
			
			// Clear all the island flags.
			for (b = m_bodyList; b; b = b.m_next)
			{
				b.m_flags &= ~b2Body.e_islandFlag;
			}
			for (var c:b2Contact = m_contactList; c; c = c.m_next)
			{
				c.m_flags &= ~b2Contact.e_islandFlag;
			}
			for (var j:b2Joint = m_jointList; j; j = j.m_next)
			{
				j.m_islandFlag = false;
			}
			
			// Build and simulate all awake islands.
			var stackSize:int = m_bodyCount;
			//b2Body** stack = (b2Body**)m_stackAllocator.Allocate(stackSize * sizeof(b2Body*));
			var stack:Vector.<b2Body> = s_stack;
			for (var seed:b2Body = m_bodyList; seed; seed = seed.m_next)
			{
				if (seed.m_flags & b2Body.e_islandFlag)
				{
					continue;
				}
				
				if (seed.IsAwake() == false || seed.IsActive() == false)
				{
					continue;
				}
				
				// The seed can be dynamic or kinematic.
				if (seed.GetType() == b2Body.b2_staticBody)
				{
					continue;
				}
				
				// Reset island and stack.
				island.Clear();
				var stackCount:int = 0;
				stack[stackCount++] = seed;
				seed.m_flags |= b2Body.e_islandFlag;
				
				// Perform a depth first search (DFS) on the constraint graph.
				while (stackCount > 0)
				{
					// Grab the next body off the stack and add it to the island.
					b = stack[--stackCount];
					//b2Assert(b.IsActive() == true);
					island.AddBody(b);
					
					// Make sure the body is awake.
					if (b.IsAwake() == false)
					{
						b.SetAwake(true);
					}
					
					// To keep islands as small as possible, we don't
					// propagate islands across static bodies.
					if (b.GetType() == b2Body.b2_staticBody)
					{
						continue;
					}
					
					var other:b2Body;
					// Search all contacts connected to this body.
					for (var ce:b2ContactEdge = b.m_contactList; ce; ce = ce.next)
					{
						// Has this contact already been added to an island?
						if (ce.contact.m_flags & b2Contact.e_islandFlag)
						{
							continue;
						}
						
						// Is this contact solid and touching?
						if (ce.contact.IsSensor() == true ||
							ce.contact.IsEnabled() == false ||
							ce.contact.IsTouching() == false)
						{
							continue;
						}
						
						island.AddContact(ce.contact);
						ce.contact.m_flags |= b2Contact.e_islandFlag;
						
						//var other:b2Body = ce.other;
						other = ce.other;
						
						// Was the other body already added to this island?
						if (other.m_flags & b2Body.e_islandFlag)
						{
							continue;
						}
						
						//b2Settings.b2Assert(stackCount < stackSize);
						stack[stackCount++] = other;
						other.m_flags |= b2Body.e_islandFlag;
					}
					
					// Search all joints connect to this body.
					for (var jn:b2JointEdge = b.m_jointList; jn; jn = jn.next)
					{
						if (jn.joint.m_islandFlag == true)
						{
							continue;
						}
						
						other = jn.other;
						
						// Don't simulate joints connected to inactive bodies.
						if (other.IsActive() == false)
						{
							continue;
						}
						
						island.AddJoint(jn.joint);
						jn.joint.m_islandFlag = true;
						
						if (other.m_flags & b2Body.e_islandFlag)
						{
							continue;
						}
						
						//b2Settings.b2Assert(stackCount < stackSize);
						stack[stackCount++] = other;
						other.m_flags |= b2Body.e_islandFlag;
					}
				}
				island.Solve(step, m_gravity, m_allowSleep);
				
				// Post solve cleanup.
				for (var i:int = 0; i < island.m_bodyCount; ++i)
				{
					// Allow static bodies to participate in other islands.
					b = island.m_bodies[i];
					if (b.GetType() == b2Body.b2_staticBody)
					{
						b.m_flags &= ~b2Body.e_islandFlag;
					}
				}
			}
			
			//m_stackAllocator.Free(stack);
			for (i = 0; i < stack.length; ++i)
			{
				if (!stack[i]) break;
				stack[i] = null;
			}
			
			// Synchronize fixutres, check for out of range bodies.
			for (b = m_bodyList; b; b = b.m_next)
			{
				if (b.IsAwake() == false || b.IsActive() == false)
				{
					continue;
				}
				
				if (b.GetType() == b2Body.b2_staticBody)
				{
					continue;
				}
				
				// Update fixtures (for broad-phase).
				b.SynchronizeFixtures();
			}
			
			// Look for new contacts.
			m_contactManager.FindNewContacts();
			
		}
		
		// Find TOI contacts and solve them.
		public function SolveTOI(step:b2TimeStep):void
		{
			
			var b:b2Body;
			var fA:b2Fixture;
			var fB:b2Fixture;
			var bA:b2Body;
			var bB:b2Body;
			var cEdge:b2ContactEdge;
			var j:b2Joint;
			
			// Reserve an island and a queue for TOI island solution.
			var island:b2Island = m_island;
			island.Initialize(m_bodyCount, b2Settings.b2_maxTOIContactsPerIsland, b2Settings.b2_maxTOIJointsPerIsland, null, m_contactManager.m_contactListener, m_contactSolver);
			
			//Simple one pass queue
			//Relies on the fact that we're only making one pass
			//through and each body can only be pushed/popped one.
			//To push:
			//  queue[queueStart+queueSize++] = newElement;
			//To pop:
			//  poppedElement = queue[queueStart++];
			//  --queueSize;
			
			var queue:Vector.<b2Body> = s_queue;
			
			for (b = m_bodyList; b; b = b.m_next)
			{
				b.m_flags &= ~b2Body.e_islandFlag;
				b.m_sweep.t0 = 0.0;
			}
			
			var c:b2Contact;
			for (c = m_contactList; c; c = c.m_next)
			{
				// Invalidate TOI
				c.m_flags &= ~(b2Contact.e_toiFlag | b2Contact.e_islandFlag);
			}
			
			for (j = m_jointList; j; j = j.m_next)
			{
				j.m_islandFlag = false;
			}
			
			// Find TOI events and solve them.
			while (true)
			{
				// Find the first TOI.
				var minContact:b2Contact = null;
				var minTOI:Number = 1.0;
				
				for (c = m_contactList; c; c = c.m_next)
				{
					// Can this contact generate a solid TOI contact?
					if (c.IsSensor() == true ||
						c.IsEnabled() == false ||
						c.IsContinuous() == false)
					{
						continue;
					}
					
					// TODO_ERIN keep a counter on the contact, only respond to M TOIs per contact.
					
					var toi:Number = 1.0;
					if (c.m_flags & b2Contact.e_toiFlag)
					{
						// This contact has a valid cached TOI.
						toi = c.m_toi;
					}
					else
					{
						// Compute the TOI for this contact.
						fA = c.m_fixtureA;
						fB = c.m_fixtureB;
						bA = fA.m_body;
						bB = fB.m_body;
						
						if ((bA.GetType() != b2Body.b2_dynamicBody || bA.IsAwake() == false) &&
							(bB.GetType() != b2Body.b2_dynamicBody || bB.IsAwake() == false))
						{
							continue;
						}
						
						// Put the sweeps onto the same time interval.
						var t0:Number = bA.m_sweep.t0;
						
						if (bA.m_sweep.t0 < bB.m_sweep.t0)
						{
							t0 = bB.m_sweep.t0;
							bA.m_sweep.Advance(t0);
						}
						else if (bB.m_sweep.t0 < bA.m_sweep.t0)
						{
							t0 = bA.m_sweep.t0;
							bB.m_sweep.Advance(t0);
						}
						
						//b2Settings.b2Assert(t0 < 1.0f);
						
						// Compute the time of impact.
						toi = c.ComputeTOI(bA.m_sweep, bB.m_sweep);
						b2Settings.b2Assert(0.0 <= toi && toi <= 1.0);
						
						// If the TOI is in range ...
						if (toi > 0.0 && toi < 1.0)
						{
							// Interpolate on the actual range.
							//toi = Math.min((1.0 - toi) * t0 + toi, 1.0);
							toi = (1.0 - toi) * t0 + toi;
							if (toi > 1) toi = 1;
						}
						
						c.m_toi = toi;
						c.m_flags |= b2Contact.e_toiFlag;
					}
					
					if (Number.MIN_VALUE < toi && toi < minTOI)
					{
						// This is the minimum TOI found so far.
						minContact = c;
						minTOI = toi;
					}
				}
				
				if (minContact == null || 1.0 - 100.0 * Number.MIN_VALUE < minTOI)
				{
					// No more TOI events. Done!
					break;
				}
				
				// Advance the bodies to the TOI.
				fA = minContact.m_fixtureA;
				fB = minContact.m_fixtureB;
				bA = fA.m_body;
				bB = fB.m_body;
				s_backupA.Set(bA.m_sweep);
				s_backupB.Set(bB.m_sweep);
				bA.Advance(minTOI);
				bB.Advance(minTOI);
				
				// The TOI contact likely has some new contact points.
				minContact.Update(m_contactManager.m_contactListener);
				minContact.m_flags &= ~b2Contact.e_toiFlag;
				
				// Is the contact solid?
				if (minContact.IsSensor() == true ||
					minContact.IsEnabled() == false)
				{
					// Restore the sweeps
					bA.m_sweep.Set(s_backupA);
					bB.m_sweep.Set(s_backupB);
					bA.SynchronizeTransform();
					bB.SynchronizeTransform();
					continue;
				}
				
				// Did numerical issues prevent;,ontact pointjrom being generated
				if (minContact.IsTouching() == false)
				{
					// Give up on this TOI
					continue;
				}
				
				// Build the TOI island. We need a dynamic seed.
				var seed:b2Body = bA;
				if (seed.GetType() != b2Body.b2_dynamicBody)
				{
					seed = bB;
				}
				
				// Reset island and queue.
				island.Clear();
				var queueStart:int = 0;	//start index for queue
				var queueSize:int = 0;	//elements in queue
				queue[queueStart + queueSize++] = seed;
				seed.m_flags |= b2Body.e_islandFlag;
				
				// Perform a breadth first search (BFS) on the contact graph.
				while (queueSize > 0)
				{
					// Grab the next body off the stack and add it to the island.
					b = queue[queueStart++];
					--queueSize;
					
					island.AddBody(b);
					
					// Make sure the body is awake.
					if (b.IsAwake() == false)
					{
						b.SetAwake(true);
					}
					
					// To keep islands as small as possible, we don't
					// propagate islands across static or kinematic bodies.
					if (b.GetType() != b2Body.b2_dynamicBody)
					{
						continue;
					}
					
					// Search all contacts connected to this body.
					for (cEdge = b.m_contactList; cEdge; cEdge = cEdge.next)
					{
						// Does the TOI island still have space for contacts?
						if (island.m_contactCount == island.m_contactCapacity)
						{
							break;
						}
						
						// Has this contact already been added to an island?
						if (cEdge.contact.m_flags & b2Contact.e_islandFlag)
						{
							continue;
						}
						
						// Skip sperate, sensor, or disabled contacts.
						if (cEdge.contact.IsSensor() == true ||
							cEdge.contact.IsEnabled() == false ||
							cEdge.contact.IsTouching() == false)
						{
							continue;
						}
						
						island.AddContact(cEdge.contact);
						cEdge.contact.m_flags |= b2Contact.e_islandFlag;
						
						// Update other body.
						var other:b2Body = cEdge.other;
						
						// Was the other body already added to this island?
						if (other.m_flags & b2Body.e_islandFlag)
						{
							continue;
						}
						
						// Synchronize the connected body.
						if (other.GetType() != b2Body.b2_staticBody)
						{
							other.Advance(minTOI);
							other.SetAwake(true);
						}
						
						//b2Settings.b2Assert(queueStart + queueSize < queueCapacity);
						queue[queueStart + queueSize] = other;
						++queueSize;
						other.m_flags |= b2Body.e_islandFlag;
					}
					
					for (var jEdge:b2JointEdge = b.m_jointList; jEdge; jEdge = jEdge.next)
					{
						if (island.m_jointCount == island.m_jointCapacity)
							continue;
						
						if (jEdge.joint.m_islandFlag == true)
							continue;
						
						other = jEdge.other;
						if (other.IsActive() == false)
						{
							continue;
						}
						
						island.AddJoint(jEdge.joint);
						jEdge.joint.m_islandFlag = true;
						
						if (other.m_flags & b2Body.e_islandFlag)
							continue;
						
						// Synchronize the connected body.
						if (other.GetType() != b2Body.b2_staticBody)
						{
							other.Advance(minTOI);
							other.SetAwake(true);
						}
						
						//b2Settings.b2Assert(queueStart + queueSize < queueCapacity);
						queue[queueStart + queueSize] = other;
						++queueSize;
						other.m_flags |= b2Body.e_islandFlag;
					}
				}
				
				var subStep:b2TimeStep = s_timestep;
				subStep.warmStarting = false;
				subStep.dt = (1.0 - minTOI) * step.dt;
				subStep.inv_dt = 1.0 / subStep.dt;
				subStep.dtRatio = 0.0;
				subStep.velocityIterations = step.velocityIterations;
				subStep.positionIterations = step.positionIterations;
				
				island.SolveTOI(subStep);
				
				var i:int;
				// Post solve cleanup.
				for (i = 0; i < island.m_bodyCount; ++i)
				{
					// Allow bodies to participate in future TOI islands.
					b = island.m_bodies[i];
					b.m_flags &= ~b2Body.e_islandFlag;
					
					if (b.IsAwake() == false)
					{
						continue;
					}
					
					if (b.GetType() != b2Body.b2_dynamicBody)
					{
						continue;
					}
					
					// Update fixtures (for broad-phase).
					b.SynchronizeFixtures();
					
					// Invalidate all contact TOIs associated with this body. Some of these
					// may not be in the island because they were not touching.
					for (cEdge = b.m_contactList; cEdge; cEdge = cEdge.next)
					{
						cEdge.contact.m_flags &= ~b2Contact.e_toiFlag;
					}
				}
				
				for (i = 0; i < island.m_contactCount; ++i)
				{
					// Allow contacts to participate in future TOI islands.
					c = island.m_contacts[i];
					c.m_flags &= ~(b2Contact.e_toiFlag | b2Contact.e_islandFlag);
				}
				
				for (i = 0; i < island.m_jointCount; ++i)
				{
					// Allow joints to participate in future TOI islands
					j = island.m_joints[i];
					j.m_islandFlag = false;
				}
				
				// Commit fixture proxy movements to the broad-phase so that new contacts are created.
				// Also, some contacts can be destroyed.
				m_contactManager.FindNewContacts();
			}
			
			//m_stackAllocator.Free(queue);
		}
		
		//
		public function DrawJoint(joint:b2Joint):void
		{
			
			var b1:b2Body = joint.GetBodyA();
			var b2:b2Body = joint.GetBodyB();
			var xf1:b2Transform = b1.m_xf;
			var xf2:b2Transform = b2.m_xf;
			var x1:b2Vec2 = xf1.position;
			var x2:b2Vec2 = xf2.position;
			var p1:b2Vec2 = joint.GetAnchorA();
			var p2:b2Vec2 = joint.GetAnchorB();
			
			//b2Color color(0.5f, 0.8f, 0.8f);
			var color:b2Color = s_jointColor;
			
			switch (joint.m_type)
			{
				case b2Joint.e_distanceJoint:
					m_debugDraw.DrawSegment(p1, p2, color);
					break;
				
				case b2Joint.e_pulleyJoint:
				{
					var pulley:b2PulleyJoint = (joint as b2PulleyJoint);
					var s1:b2Vec2 = pulley.GetGroundAnchorA();
					var s2:b2Vec2 = pulley.GetGroundAnchorB();
					m_debugDraw.DrawSegment(s1, p1, color);
					m_debugDraw.DrawSegment(s2, p2, color);
					m_debugDraw.DrawSegment(s1, s2, color);
				}
					break;
				
				case b2Joint.e_mouseJoint:
					m_debugDraw.DrawSegment(p1, p2, color);
					break;
				
				default:
					if (b1 != m_groundBody)
						m_debugDraw.DrawSegment(x1, p1, color);
					m_debugDraw.DrawSegment(p1, p2, color);
					if (b2 != m_groundBody)
						m_debugDraw.DrawSegment(x2, p2, color);
			}
		}
		
		public function DrawShape(shape:b2Shape, xf:b2Transform, color:b2Color):void
		{
			
			switch (shape.m_type)
			{
				case b2Shape.e_circleShape:
				{
					var circle:b2CircleShape = (shape as b2CircleShape);
					
					var center:b2Vec2 = b2Math.MulX(xf, circle.m_p);
					var radius:Number = circle.m_radius;
					var axis:b2Vec2 = xf.R.col1;
					
					m_debugDraw.DrawSolidCircle(center, radius, axis, color);
				}
					break;
				
				case b2Shape.e_polygonShape:
				{
					var i:int;
					var poly:b2PolygonShape = (shape as b2PolygonShape);
					var vertexCount:int = poly.GetVertexCount();
					var localVertices:Vector.<b2Vec2> = poly.GetVertices();
					
					var vertices:Vector.<b2Vec2> = new Vector.<b2Vec2>();
					
					for (i = 0; i < vertexCount; ++i)
					{
						vertices[i] = b2Math.MulX(xf, localVertices[i]);
					}
					
					m_debugDraw.DrawSolidPolygon(vertices, vertexCount, color);
				}
					break;
				
				case b2Shape.e_edgeShape:
				{
					var edge:b2EdgeShape = shape as b2EdgeShape;
					
					m_debugDraw.DrawSegment(b2Math.MulX(xf, edge.GetVertex1()), b2Math.MulX(xf, edge.GetVertex2()), color);
					
				}
					break;
			}
		}
		
	};
	
}
",12426,False,2306.0748945976206,median
"package{
	import flash.display.*;
	import flash.net.*;
	import fl.controls.*;
	import flash.events.*;
	import fl.events.*;
	import flash.system.Security;
	
	public class wordGame extends MovieClip {
		private var nc:NetConnection;
		private var so:SharedObject;
		private var b;
		private var c;
		private var begining;
		private var username;
		private var playing;
		private var coplayer;
		private var currentword;
		private var mysolution = """";
		private var otherssolution = """";
		private var towns:Array = new Array( ""Αγίας Βαρβάρας"", ""Αγίας Παρασκευής"", ""Αγίου Δημητρίου"", ""Αγίων Αναργύρων"", ""Αθήνα"", ""Αιγάλεω"", ""Αλίμου"", ""Αμαρουσίου"", ""Αργυρουπόλεως"", ""Βριλησσίων"", ""Βύρωνος"", ""Γαλατσίου"", ""Γλυφάδας"", ""Δάφνης"", ""Εκάλης"", ""Ελληνικού"", ""Ζωγράφου"", ""Ηλιουπόλεως"", ""Ιλίου (Νέων Λιοσίων)"", ""Καισαριανής"", ""Καλλιθέας"", ""Καματερού"", ""Κηφισιάς"", ""Λυκοβρύσεως"", ""Μελισσίων"", ""Μεταμορφώσεως"", ""Μοσχάτου"", ""Ν. Ηρακλείου"", ""Νέας Ερυθραίας"", ""Νέας Ιωνίας"", ""Νέας Πεντέλης"", ""Νέας Σμύρνης"", ""Νέας Φιλαδέλφειας"", ""Νέας Χαλκηδόνος"", ""Νέου Ψυχικού"", ""Παλαιού Φαλήρου"", ""Παπάγου"", ""Πεντέλης"", ""Περιστερίου"", ""Πετρουπόλεως"", ""Πεύκης"", ""Ταύρου"", ""Υμηττού"", ""Φιλοθέης"", ""Χαλανδρίου"", ""Χαϊδαρίου"", ""Χολαργού"", ""Ψυχικού"", ""Αγγελοκάστρου"", ""Αγρινίου"", ""Αιτωλικού"", ""Αλυζίας"", ""Αμφιλοχίας"", ""Ανακτορίου"", ""Αντιρρίου"", ""Αποδοτίας"", ""Αρακύνθου"", ""Αστακού"", ""Θέρμου"", ""Θεστιέων"", ""Ινάχου"", ""Μακρυνείας"", ""Μεδεώνος"", ""Μενιδίου"", ""Μεσολογγίου"", ""Ναυπάκτου"", ""Νεάπολης"", ""Οινιάδων"", ""Παλαίρου"", ""Παναιτωλικού"", ""Παραβόλας"", ""Παρακαμπυλίων"", ""Πλατάνου"", ""Πυλλήνης"", ""Στράτου"", ""Φυτειών"", ""Χάλκειας"", ""Αγίου Κωνσταντίνου"", ""Αγίου Στεφάνου"", ""Αναβύσσου"", ""Ανθούσης"", ""Ανοίξεως"", ""Αρτέμιδος (Λούτσα)"", ""Αυλώνος"", ""Αφιδνών"", ""Αχαρνών"", ""Βάρης"", ""Βαρνάβα"", ""Βουλιαγμένης"", ""Βούλας"", ""Γέρακα"", ""Γλυκών Νερών"", ""Γραμματικού"", ""Διονύσου"", ""Δροσιάς"", ""Θρακομακεδόνων"", ""Καλάμου"", ""Καλυβίων Θορικού"", ""Καπανδριτίου"", ""Κερατέας"", ""Κουβαρά"", ""Κρυονερίου"", ""Κρωπίας"", ""Λαυρεωτικής"", ""Μαλακάσης"", ""Μαραθώνος"", ""Μαρκόπουλου"", ""Νέας Μάκρης"", ""Νέων Παλατίων"", ""Παιανίας"", ""Παλαιάς Φωκαίας"", ""Παλλήνης"", ""Πικερμίου"", ""Πολυδενδρίου"", ""Ραφήνας"", ""Ροδοπόλεως"", ""Σαρωνίδος"", ""Σκάλας Ωρωπού"", ""Σπάτων"", ""Σταμάτας"", ""Συκαμίνου"", ""Ωρωπίων"", ""Άργους"", ""Αλέας"", ""Ασίνης"", ""Ασκληπιείου"", ""Αχλαδοκάμπου"", ""Επιδαύρου"", ""Ερμιόνης"", ""Κουτσοποδίου"", ""Κρανιδίου"", ""Λέρνας"", ""Λυρκείας"", ""Μιδέας"", ""Μυκηναίων"", ""Νέας Κίου"", ""Νέας Τίρυνθας"", ""Ναυπλιέων"", ""Απόλλωνος"", ""Βαλτετσίου"", ""Βυτίνας"", ""Βόρειας Κυνουρίας"", ""Γόρτυνος"", ""Δημητσάνας"", ""Ηραίας"", ""Κλείτορος"", ""Κοντοβαζαίνης"", ""Κορυθίου"", ""Κοσμά"", ""Λαγκαδίων"", ""Λεβιδίου"", ""Λεωνιδίου"", ""Μαντινείας"", ""Μεγαλόπολης"", ""Σκυρίτιδας"", ""Τεγέας"", ""Τρίπολης"", ""Τρικολώνων"", ""Τροπαίων"", ""Φαλάνθου"", ""Φαλαισίας"", ""Άρτας"", ""Αγνάντων"", ""Αθαμανίας"", ""Αμβρακικού"", ""Αράχθου"", ""Βλαχερνών"", ""Γεωργίου Καραϊσκάκη"", ""Ηρακλείας Αρτης"", ""Θεοδωριάνων"", ""Κομμένου"", ""Κομποτίου"", ""Μελισσουργών"", ""Ξηροβουνίου"", ""Πέτα"", ""Τετραφυλίας"", ""Φιλοθέης Αρτης"", ""Αιγίου"", ""Αιγείρας"", ""Ακράτας"", ""Αροανίας"", ""Βραχναιίκων"", ""Διακοπτού"", ""Δύμης"", ""Ερινεού"", ""Καλαβρύτων"", ""Καλεντζίου"", ""Λαρίσσου"", ""Λεοντίου"", ""Λευκασίου"", ""Μεσσάτιδος"", ""Μόβρης"", ""Πάτρα"", ""Παραλίας Αχαϊας"", ""Παϊων"", ""Ρίου"", ""Συμπολιτείας"", ""Τριταίας"", ""Φαρρών"", ""Ωλενίας"", ""Ακραιφνίας"", ""Αλιάρτου"", ""Αντικύρας"", ""Αραχώβης"", ""Βαγίων"", ""Δαύλειας"", ""Δερβενοχωρίων"", ""Διστόμου"", ""Θίσβης"", ""Θεσπιέων"", ""Θηβαίων"", ""Κορώνειας Βοιωτίας"", ""Κυριακίου"", ""Λιβαδιά"", ""Οινοφύτων"", ""Ορχομενού"", ""Πλαταιών"", ""Σχηματαρίου"", ""Τανάγρας"", ""Χαιρωνείας"", ""Αβδέλλας"", ""Βεντζίου"", ""Γρεβενών"", ""Γόργιανης"", ""Δεσκάτης"", ""Δοτσικού"", ""Ηρακλεωτών"", ""Θεόδωρου Ζιάκα"", ""Κοσμά του Αιτωλού"", ""Μεσολουρίου"", ""Περιβολίου"", ""Σαμαρίνης"", ""Σμίξης"", ""Φιλιππαίων"", ""Χασίων Γρεβενών"", ""Δοξάτου"", ""Δράμας"", ""Κάτω Νευροκοπίου"", ""Καλαμπακίου"", ""Νικηφόρου"", ""Παρανεστίου"", ""Προσοτσάνης"", ""Σιδηρονέρου"", ""Σιταγρών"", ""Ανω Λιοσίων"", ""Ασπροπύργου"", ""Βιλίων"", ""Ελευσίνας"", ""Ερυθρών"", ""Ζεφυρίου"", ""Μάνδρας"", ""Μαγούλας"", ""Μεγάρων"", ""Νέας Περάμου"", ""Οινόης"", ""Φυλής"", ""Αγαθονησίου"", ""Αρχαγγέλου"", ""Αστυπάλαιας"", ""Ατταβύρου"", ""Αφάντου"", ""Δικαίου"", ""Ηρακλειδών"", ""Ιαλυσού"", ""Κάσου"", ""Καλλιθέας Δωδεκανήσου"", ""Καλυμνίων"", ""Καμείρου"", ""Καρπάθου"", ""Κως"", ""Λέρου"", ""Λίνδος"", ""Λειψών"", ""Μεγίστης"", ""Νισύρου"", ""Νότιας Ρόδου"", ""Ολύμπου Καρπάθου"", ""Πάτμου"", ""Πεταλούδων"", ""Ρόδος"", ""Σύμης"", ""Τήλου"", ""Χάλκης"", ""Αλεξανδρούπολης"", ""Βύσσας"", ""Διδυμοτείχου"", ""Κυπρίνου"", ""Μεταξάδων"", ""Ορεστιάδας"", ""Ορφέα"", ""Σαμοθράκης"", ""Σουφλίου"", ""Τραϊανούπολης"", ""Τριγώνου"", ""Τυχερού"", ""Φερών Έβρου"", ""Αιδηψού"", ""Αμαρυνθίων"", ""Ανθηδώνος"", ""Αρτεμισίου"", ""Αυλίδος"", ""Αυλώνος Ευβοίας"", ""Διρφύων"", ""Δυστίων"", ""Ελυμνίων"", ""Ερέτριας"", ""Ιστιαίας"", ""Καρύστου"", ""Καφηρέως"", ""Κηρέως"", ""Κονιστρών"", ""Κύμης"", ""Ληλαντίων"", ""Λιχάδος"", ""Μαρμαρίου"", ""Μεσσαπίων"", ""Νέας Αρτάκης"", ""Νηλέως"", ""Σκύρου"", ""Στυραίων"", ""Ταμιναίων"", ""Χαλκιδέων"", ""Ωρεών"", ""Αγράφων"", ""Απεραντίων"", ""Ασπροποτάμου Ευρυτανίας"", ""Βίνιανης"", ""Δομνίστας"", ""Καρπενησίου"", ""Κτημενίων"", ""Ποταμιάς"", ""Προυσσού"", ""Φουρνά"", ""Φραγκίστας"", ""Αλυκών"", ""Αρκαδίων"", ""Αρτεμισίων Ζακύνθου"", ""Ελατίων"", ""Ζακυνθίων"", ""Λαγανά"", ""Αλιφείρας"", ""Αμαλιάδος"", ""Ανδραβίδας"", ""Ανδριτσαίνης"", ""Αρχαίας Ολυμπίας"", ""Βαρθολομιού"", ""Βουπρασίας"", ""Βώλακος"", ""Γαστούνης"", ""Ζαχάρως"", ""Ιαρδάνου"", ""Κάστρου - Κυλλήνης"", ""Λαμπείας"", ""Λασιώνος"", ""Λεχαινών"", ""Πηνείας"", ""Πύργου"", ""Σκιλλούντος"", ""Τραγανού"", ""Φιγαλείας"", ""Φολόης"", ""Ωλένης"", ""Αλεξάνδρειας"", ""Ανθεμίων"", ""Αντιγονιδών"", ""Αποστόλου Παύλου"", ""Βέροιας"", ""Βεργίνας"", ""Δοβρά"", ""Ειρηνούπολης"", ""Μακεδονίδος"", ""Μελίκης"", ""Νάουσας"", ""Πλατέος"", ""Αγίας Βαρβάρας"", ""Αρκαλοχωρίου"", ""Αρχανών"", ""Αστερουσιών"", ""Βιάννου"", ""Γαζίου"", ""Γοργολαϊνη"", ""Γουβών"", ""Γόρτυνας"", ""Επισκοπής"", ""Ζαρού"", ""Ηρακλείου"", ""Θραψανού"", ""Καστελλίου"", ""Κρουσώνα"", ""Κόφινα"", ""Μαλλίων"", ""Μοιρών"", ""Νέας Αλικαρνασσού"", ""Νίκου Καζαντζάκη"", ""Παλιανής"", ""Ρούβα"", ""Τεμένους"", ""Τυλίσου"", ""Τυμπακίου"", ""Χερσονήσου"", ""Αχέροντα"", ""Ηγουμενίτσης"", ""Μαργαριτίου"", ""Πέρδικας"", ""Παραμυθιάς"", ""Παραποτάμου"", ""Σαγιάδας"", ""Σουλίου"", ""Συβότων"", ""Φιλιατών"", ""Αγίου Αθανασίου"", ""Αγίου Γεωργίου"", ""Αγίου Παύλου"", ""Αμπελοκήπων"", ""Αξιού"", ""Απολλωνίας"", ""Αρέθουσας"", ""Ασσήρου"", ""Βασιλικών"", ""Βερτίσκου"", ""Εγνατίας"", ""Ελευθερίου"", ""Επανομής"", ""Ευκαρπίας"", ""Ευόσμου"", ""Εχεδώρου"", ""Θέρμης"", ""Θερμαϊκού"", ""Θεσσαλονίκη"", ""Καλαμαριάς"", ""Καλλιθέας Θεσσαλονίκης"", ""Καλλινδοίων"", ""Κορωνείας"", ""Κουφαλίων"", ""Λαγκαδά"", ""Λαχανά"", ""Μίκρας"", ""Μαδύτου"", ""Μενεμένης"", ""Μηχανιώνας"", ""Μυγδονίας"", ""Νεαπόλεως"", ""Πανοράματος"", ""Πεύκων"", ""Πολίχνης"", ""Πυλαίας"", ""Ρεντίνας"", ""Σοχού"", ""Σταυρουπόλεως"", ""Συκεών"", ""Τριανδρίας"", ""Χαλάστρας"", ""Χαλκηδόνος"", ""Χορτιάτη"", ""Ωραιοκάστρου"", ""Αγίου Δημητρίου"", ""Αετομηλίτσης"", ""Ανατολής"", ""Ανατολικού Ζαγορίου"", ""Ανω Καλαμά"", ""Ανω Πωγωνίου"", ""Βαθυπέδου"", ""Βοβούσης"", ""Δελβινακίου"", ""Διστράτου"", ""Δωδώνης"", ""Εγνατίας Ιωαννίνων"", ""Εκάλης Ιωαννίνων"", ""Ευρυμενών Ιωαννίνων"", ""Ζίτσας"", ""Ιωάννινα"", ""Καλαριτών"", ""Καλπακίου"", ""Κατσανοχωρίων"", ""Κεντρικού Ζαγορίου"", ""Κόνιτσας"", ""Λάβδανης"", ""Λάκκας Σουλίου"", ""Μαστοροχωρίων"", ""Ματσουκίου"", ""Μετσόβου"", ""Μηλέας"", ""Μολοσσών"", ""Μπιζανίου"", ""Νήσου Ιωαννίνων"", ""Παμβώτιδος"", ""Παπίγκου"", ""Πασαρώνος"", ""Περάματος"", ""Πραμάντων"", ""Πωγωνιανής"", ""Σελλών"", ""Σιράκου"", ""Τζουμέρκων"", ""Τύμφης"", ""Φούρκας"", ""Ελευθερούπολης"", ""Ελευθερών"", ""Θάσου"", ""Καβάλας"", ""Κεραμωτής"", ""Ορεινού"", ""Ορφανού"", ""Παγγαίου"", ""Πιερέων"", ""Φιλίππων"", ""Χρυσούπολης"", ""Άρνης"", ""Αθαμανών"", ""Αργιθέας"", ""Αχελώου"", ""Ιθώμης Καρδίτσης"", ""Ιτάμου"", ""Κάμπου"", ""Καλλιφώνου"", ""Καρδίτσας"", ""Μενελαϊδας"", ""Μητρόπολης"", ""Μουζακίου"", ""Νεβρόπολης Αγράφων"", ""Παλαμά"", ""Παμίσου"", ""Πλαστήρα"", ""Ρεντίνης"", ""Σελλάνων"", ""Σοφάδων"", ""Ταμασίου"", ""Φύλλου"", ""Ίωνος Δραγούμη"", ""Αγίας Τριάδος"", ""Αγίων Αναργύρων Καστοριάς"", ""Ακριτών"", ""Αργους Ορεστικού"", ""Αρρένων"", ""Βιτσίου"", ""Γράμου"", ""Καστοριάς"", ""Καστρακίου"", ""Κλεισούρας"", ""Κορεστίων"", ""Μακέδνων"", ""Μεσοποταμίας"", ""Νεστορίου"", ""Αγίου Γεωργίου Κερκύρας"", ""Αχιλλείων"", ""Ερεικούσσης"", ""Εσπερίων"", ""Θιναλίου"", ""Κέρκυρα"", ""Κασσωπαίων"", ""Κορισσίων"", ""Λευκιμμαίων"", ""Μαθρακίου"", ""Μελιτειέων"", ""Οθωνών"", ""Παλαιοκαστριτών"", ""Παξών"", ""Παρελίων"", ""Φαιάκων"", ""Αργοστολίου"", ""Ελειού - Πρόνων"", ""Ερίσου"", ""Ιθάκης"", ""Λειβαθούς"", ""Ομαλών"", ""Παλικής"", ""Πυλαρέων"", ""Σάμης"", ""Αξιούπολης"", ""Γαλλικού"", ""Γουμένισσας"", ""Δοϊράνης"", ""Ευρωπού"", ""Κιλκίς"", ""Κρουσσών"", ""Λιβαδίων Κιλκίς"", ""Μουριών"", ""Πικρολίμνης"", ""Πολυκάστρου"", ""Χέρσου"", ""Αγίας Παρασκευής Κοζάνης"", ""Αιανής"", ""Ασκίου"", ""Βελβεντού"", ""Βερμίου"", ""Βλάστης"", ""Δημητρίου Υψηλάντη"", ""Ελιμείας"", ""Ελλησπόντου"", ""Καμβουνίων"", ""Κοζάνης"", ""Λιβαδερού"", ""Μουρικίου"", ""Νεάπολης Κοζάνης"", ""Πενταλόφου"", ""Πτολεμαϊδας"", ""Σερβίων"", ""Σιάτιστας"", ""Τσοτυλίου"", ""Άσσου-Λεχαίου"", ""Αγίων Θεοδώρων"", ""Βέλου"", ""Βόχας"", ""Ευρωστίνης"", ""Κορινθίων"", ""Λουτρακίου-Περαχώρας"", ""Νεμέας"", ""Ξυλοκάστρου"", ""Σαρωνικού"", ""Σικυωνίων"", ""Σολυγείας"", ""Στυμφαλίας"", ""Τενέας"", ""Φενεού"", ""Άνδρου"", ""Άνω Σύρου"", ""Αμοργού"", ""Ανάφης"", ""Αντιπάρου"", ""Δονούσης"", ""Δρυμαλίας"", ""Εξωμβούργου"", ""Ερμουπόλεως"", ""Ηράκλειας"", ""Θήρας"", ""Ιος"", ""Κέας"", ""Κιμώλου"", ""Κορθίου"", ""Κουφονησίων"", ""Κύθνου"", ""Μήλου"", ""Μυκόνου"", ""Νάξου"", ""Οίας"", ""Πάρου"", ""Πανόρμου"", ""Ποσειδωνίας"", ""Σίφνου"", ""Σερίφου"", ""Σικίνου"", ""Σχοινούσσης"", ""Τήνου"", ""Υδρούσας"", ""Φολεγάνδρου"", ""Αγίας Παρασκευής Λέσβου"", ""Αγίου Ευστρατίου"", ""Αγιάσου"", ""Ατσικής"", ""Γέρας"", ""Ερεσού - Αντίσσης"", ""Ευεργέτουλα"", ""Καλλονής"", ""Λουτροπόλεως Θερμής"", ""Μήθυμνας"", ""Μανταμάδου"", ""Μούδρου"", ""Μυτιλήνης"", ""Μύρινας"", ""Νέας Κούταλης"", ""Πέτρας"", ""Πλωμαρίου"", ""Πολιχνίτου"", ""Έλους"", ""Ανατολικής Μάνης"", ""Ασωπού"", ""Βοιών"", ""Γερόνθρων"", ""Γυθείου"", ""Ελαφονήσου"", ""Ζάρακα"", ""Θεραπνών"", ""Καρυών"", ""Κροκεών"", ""Μολάων"", ""Μονεμβασίας"", ""Μυστρά"", ""Νιάτων"", ""Οινούντος"", ""Οιτύλου"", ""Πελλάνας"", ""Σκάλας"", ""Σμύνους"", ""Σπάρτης"", ""Φαρίδος"", ""Αγιάς"", ""Αμπελακίων Λαρίσης"", ""Αμπελώνος"", ""Αντιχασίων"", ""Αρμενίου"", ""Βερδικούσης"", ""Γιάννουλης"", ""Γόννων"", ""Ελασσόνας"", ""Ενιππέα"", ""Ευρυμενών Λαρίσης"", ""Κάτω Ολύμπου"", ""Καρυάς"", ""Κιλελέρ"", ""Κοιλάδας"", ""Κραννώνος"", ""Λάρισας"", ""Λακέρειας"", ""Λιβαδίου Λαρίσης"", ""Μακρυχωρίου"", ""Μελιβοίας"", ""Νέσσωνος"", ""Νίκαιας Λαρίσης"", ""Ναρθακίου"", ""Ολύμπου"", ""Πλατυκάμπου"", ""Πολυδάμαντα"", ""Ποταμιάς Λαρίσης"", ""Σαρανταπόρου"", ""Τσαριτσάνης"", ""Τυρνάβου"", ""Φαρσάλων"", ""Αγίου Νικολάου"", ""Ιεράπετρας"", ""Ιτάνου"", ""Λεύκης"", ""Μακρύ Γιαλού"", ""Νεάπολης Λασιθίου"", ""Οροπεδίου Λασιθίου"", ""Σητείας"", ""Απολλωνίων"", ""Ελλομένου"", ""Καλάμου Λευκάδος"", ""Καρυάς Λευκάδος"", ""Καστού"", ""Λευκάδος"", ""Μεγανησίου"", ""Σφακιωτών"", ""Αγριάς"", ""Αισωνίας"", ""Αλμυρού"", ""Αλοννήσου"", ""Ανάβρας"", ""Αργαλαστής"", ""Αρτέμιδας"", ""Αφετών"", ""Βόλου"", ""Ζαγοράς"", ""Ιωλκού"", ""Κάρλας"", ""Κεραμιδίου"", ""Μακρινίτσης"", ""Μηλεών"", ""Μουρεσίου"", ""Νέας Αγχιάλου"", ""Νέας Ιωνίας Μαγνησίας"", ""Πορταριάς"", ""Πτελεού"", ""Σηπιάδος"", ""Σκιάθου"", ""Σκοπέλου"", ""Σούρπης"", ""Τρικερίου"", ""Φερών Μαγνησίας"", ""Άριος"", ""Αβίας"", ""Αετού Μεσσηνίας"", ""Αιπείας"", ""Ανδανίας"", ""Ανδρούσης"", ""Αριστομένους"", ""Αρφαρών"", ""Αυλώνος Μεσσηνίας"", ""Βουφράδων"", ""Γαργαλιάνων"", ""Δωρίου"", ""Είρας"", ""Θουρίας"", ""Ιθώμης Μεσσηνίας"", ""Καλαμάτας"", ""Κορώνης"", ""Κυπαρισσίας"", ""Λεύκτρου"", ""Μεθώνης"", ""Μελιγαλά"", ""Μεσσήνης"", ""Νέστορος"", ""Οιχαλίας Μεσσηνίας"", ""Παπαφλέσσα"", ""Πεταλιδίου"", ""Πύλου"", ""Τρικόρφου"", ""Τριπύλης"", ""Φιλιατρών"", ""Χιλιοχωρίων"", ""Αβδήρων"", ""Βιστωνίδος"", ""Θερμών Ξάνθης"", ""Κοτύλης"", ""Μύκης"", ""Ξάνθης"", ""Σατρών"", ""Σελέρου"", ""Σταυρούπολης"", ""Τοπείρου"", ""Έδεσσας"", ""Αριδαίας"", ""Βεγορίτιδας"", ""Γιαννιτσών"", ""Εξαπλατάνου"", ""Κρύας Βρύσης"", ""Κύρρου"", ""Μεγάλου Αλεξάνδρου"", ""Μενηίδος"", ""Πέλλας"", ""Σκύδρας"", ""Αίγινας"", ""Αγίου Ιωάννου Ρέντη"", ""Αγκιστρίου"", ""Αμπελακίων"", ""Αντικυθήρων"", ""Δραπετσώνας"", ""Κερατσινίου"", ""Κορυδαλλού"", ""Κυθήρων"", ""Μεθάνων"", ""Νικαίας"", ""Πειραιώς"", ""Περάματος"", ""Πόρου"", ""Σαλαμίνας"", ""Σπετσών"", ""Τροιζήνος"", ""Υδρας"", ""Αιγινίου"", ""Ανατολικού Ολύμπου"", ""Δίου"", ""Ελαφίνας"", ""Κατερίνης"", ""Κολινδρού"", ""Κορινού"", ""Λιτοχώρου"", ""Μεθώνης Πιερίας"", ""Πέτρας Πιερίας"", ""Παραλίας Πιερίας"", ""Πιερίων"", ""Πύδνας"", ""Ανωγείου"", ""Ζαλόγγου"", ""Θεσπρωτικού"", ""Κρανέας"", ""Λούρου"", ""Πάργας"", ""Πρεβέζης"", ""Φαναρίου"", ""Φιλιππιάδος"", ""Ανωγείων"", ""Αρκαδίου"", ""Γεροποτάμου"", ""Ζωνιανών"", ""Κουλούκωνα"", ""Κουρητών"", ""Λάμπης"", ""Λαππαίων"", ""Νικηφόρου Φωκά"", ""Ρεθύμνης"", ""Συβρίτου"", ""Φοίνικα"", ""Αιγείρου"", ""Αμαξάδων"", ""Αρριανών"", ""Ιάσμου"", ""Κέχρου"", ""Κομοτηνής"", ""Μαρωνείας"", ""Νέου Σιδηροχωρίου"", ""Οργάνης"", ""Σαπών"", ""Σώστου"", ""Φιλλύρας"", ""Αγίου Κηρύκου"", ""Βαθέος"", ""Ευδήλου"", ""Καρλοβασίων"", ""Μαραθοκάμπου"", ""Πυθαγορείου"", ""Ραχών"", ""Φούρνων Κορσεών"", ""Άνω Βροντούς"", ""Αγκίστρου"", ""Αλιστράτης"", ""Αμφίπολης"", ""Αχινού"", ""Αχλαδοχωρίου"", ""Βισαλτίας"", ""Εμμανουήλ Παππά"", ""Ηρακλείας Σερρών"", ""Κερκίνης"", ""Κορμίστας"", ""Λευκώνα"", ""Μητρουσίου"", ""Νέας Ζίχνης"", ""Νιγρίτης"", ""Ορεινής"", ""Πετριτσίου"", ""Προμαχώνος"", ""Πρώτης"", ""Ροδολίβους"", ""Σερρών"", ""Σιδηροκάστρου"", ""Σκοτούσσης"", ""Σκουτάρεως"", ""Στρυμωνικού"", ""Στρυμώνα"", ""Τραγίλου"", ""Αιθήκων"", ""Ασπροποτάμου Τρικάλων"", ""Βασιλικής"", ""Γόμφων"", ""Εστιαιώτιδας"", ""Καλαμπάκας"", ""Καλλιδένδρου"", ""Καστανιάς"", ""Κλεινοβού"", ""Κόζιακα"", ""Μαλακασίου"", ""Μεγάλων Καλυβίων"", ""Μυροφύλλου"", ""Νεράιδας"", ""Οιχαλίας Τρικάλων"", ""Παληοκάστρου"", ""Παραληθαίων"", ""Πελινναίων"", ""Πιαλείων"", ""Πυνδαίων"", ""Πύλης"", ""Τρίκαλα"", ""Τυμφαίων"", ""Φαλωρείας"", ""Φαρκαδόνας"", ""Χασίων Τρικάλων"", ""Αγίου Γεωργίου Τυμφρηστού"", ""Αγίου Κωνσταντίνου Φθιώτιδος"", ""Αμφίκλειας"", ""Αταλάντης"", ""Γοργοποτάμου"", ""Δαφνουσίων"", ""Δομοκού"", ""Ελάτειας"", ""Εχιναίων"", ""Θεσσαλιώτιδος"", ""Καμένων Βούρλων"", ""Λαμία"", ""Λειανοκλαδίου"", ""Μακρακώμης"", ""Μαλεσίνης"", ""Μώλου"", ""Ξυνιάδος"", ""Οπουντίων"", ""Παύλιανης"", ""Πελασγίας"", ""Σπερχειάδος"", ""Στυλίδος"", ""Τιθορέας"", ""Τυμφρηστού"", ""Υπάτης"", ""Αετού Φλωρίνης"", ""Αμυνταίου"", ""Βαρικού"", ""Κάτω Κλεινών"", ""Κρυσταλλοπηγής"", ""Λεχόβου"", ""Μελίτης"", ""Νυμφαίου"", ""Περάσματος"", ""Πρεσπών"", ""Φιλώτα"", ""Φλώρινας"", ""Αμφίσσης"", ""Βαρδουσίων"", ""Γαλαξιδίου"", ""Γραβιάς"", ""Δελφών"", ""Δεσφίνης"", ""Ευπαλίου"", ""Ιτέας"", ""Καλλιέων"", ""Λιδορικίου"", ""Παρνασσού"", ""Τολοφώνος"", ""Αγίου Μηνά"", ""Αμανής"", ""Ιωνίας"", ""Καμποχώρων"", ""Καρδαμύλων"", ""Μαστιχοχωρίων"", ""Οινουσσών"", ""Ομηρούπολης"", ""Χίος"", ""Ψαρών"", ""Ανθεμούντα"", ""Αρναίας"", ""Ζερβοχωρίων"", ""Καλλικράτειας"", ""Κασσάνδρας"", ""Μουδανιών"", ""Ορμυλίας"", ""Παλλήνης Χαλκιδικής"", ""Παναγίας"", ""Πολυγύρου"", ""Σιθωνίας"", ""Σταγύρων-Ακάνθου"", ""Τορώνης"", ""Τρίγλιας"", ""Ακρωτηρίου"", ""Ανατολικού Σελίνου"", ""Αρμένων"", ""Ασή Γωνιάς"", ""Βάμου"", ""Βουκολιών"", ""Γαύδου"", ""Γεωργιουπόλεως"", ""Ελευθερίου Βενιζέλου"", ""Θερίσου"", ""Ιναχωρίου"", ""Καντάνου"", ""Κεραμιών"", ""Κισσάμου"", ""Κολυμβαρίου"", ""Κρυονερίδας"", ""Μουσούρων"", ""Μυθήμνης"", ""Νέας Κυδωνίας"", ""Πελεκάνου"", ""Πλατανιά"", ""Σούδας"", ""Σφακίων"", ""Φρέ"", ""Χανίων"" );

		public function wordGame(){
			Security.allowDomain( ""*"" );
			nc = new NetConnection();
			nc.connect(""rtmp://europa.kamibu.com/SOSample"");
			so = SharedObject.getRemote(""SampleChat"", nc.uri, false); 
			so.connect( nc );
			so.addEventListener( SyncEvent.SYNC, SOSyncHandler );
			b = new TextArea();
			c = new TextInput();
			b.width = 200;
			b.height = 200;
			c.width = 200;
			c.height = 25;
			c.y = 200;
			stage.addChild( b );
			stage.addChild( c );
			c.addEventListener( ComponentEvent.ENTER, InputEnterHandler );
			b.text = ""Γράψε ένα όνομα χρήστη και πάτα Enter"";
			begining = true;
		}
		
		private function SOSyncHandler( event ){
			if( so.data.SampleChat == undefined || begining ){
				return;
			}
			trace( so.data.SampleChat );
			var data = so.data.SampleChat.split( ""-"" );
			if( data.length < 2 ){
				return;
			}
			switch( data[ 1 ] ){
				case ""1"": //Someone seeks for player
					if( !playing && username != data[ 0 ]
														 ){
						so.setProperty( ""SampleChat"", username + ""-2-"" + data[ 0 ] );
						playing = true;
						coplayer = data[ 0 ];
					}
					break;
				case ""2"": //Players accept each other
					if( data[ 0 ] == coplayer && data[ 2 ] != username ){
						playing = false;
						return;
					}
					if( data[ 0 ] == coplayer && data[ 2 ] == username ){
						b.text += ""\\nΠαίζεις με τον χρήστη "" + coplayer;
					}
					if( data[ 2 ] == username && !playing ){
						playing = true;
						coplayer = data[ 0 ];
						b.text += ""\\nΠαίζεις με τον χρήστη "" + coplayer;
						so.setProperty( ""SampleChat"", username + ""-2-"" + data[ 0 ] );
						StartGame();
					}
					break;
				case ""3"": //Playing session
					if( data[ 0 ] == coplayer ){
						otherssolution = data[ 2 ];
						if( mysolution == """" ){
							return;
						}
						if( mysolution == otherssolution ){
							b.text = mysolution + "" -> Σωστή απάντηση!"";
							mysolution = otherssolution = """";
							StartGame();
							return;
						}
						b.text += ""\\nΛάθος απάντηση.."";
					}
					break;
				case ""4"": //Current word select
					if( data[ 0 ] == coplayer ){
						currentword = data[ 2 ];
						b.text += ""\\nΓράψε την πόλη \\"""" + currentword + ""\\"" στην ονομαστική"";
					}
					break;
			}
						
		}
		
		private function InputEnterHandler( event ){
			if( begining ){
				username = event.target.text;
				event.target.text = """";
				b.text = ""Το όνομα χρήστη σου είναι "" + username + ""\\nΑναμονή για παίκτη..."";
				so.setProperty( ""SampleChat"", username + ""-1"" );
				begining = false;
				return;
			}
			var text = event.target.text;
			b.text += ""\\n"" + text;
			so.setProperty( ""SampleChat"", username + ""-3-"" + text );
			mysolution = text;
			if( otherssolution != """" ){
				if( otherssolution == mysolution ){
					b.text = mysolution + "" -> Σωστή απάντηση!"";
					mysolution = otherssolution = """";
				}
				else{
					b.text += ""\\nΛάθος απάντηση.."";
				}
			}
			event.target.text = """";
		}
		
		private function StartGame(){
			currentword = towns[ Math.round( Math.random()*1033 ) ];
			b.text += ""\\nΓράψε την πόλη \\"""" + currentword + ""\\"" στην ονομαστική"";
			so.setProperty( ""SampleChat"", username + ""-4-"" + currentword );
		}
	}
}",12405,True,3692.6902631454614,median
"/*

  UpdateArea.ino
  
  Demonstration for the UpdateDisplayArea command

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED
//U8G2_SSD1306_72X40_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD0323_OS128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD0323_OS128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 		// Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); 	 // Not tested
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_MAX7219_64X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_32X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_8X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_LS013B7DH03_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V


// End of constructor list

int16_t offset;				// current offset for the scrolling text
u8g2_uint_t width;			// pixel width of the scrolling text (must be lesser than 128 unless U8G2_16BIT is defined
const char *text = ""U8g2"";	// scroll this text from right to left

const uint8_t tile_area_x_pos = 2;	// Update area left position (in tiles)
const uint8_t tile_area_y_pos = 3;	// Update area upper position (distance from top in tiles)
const uint8_t tile_area_width = 12;
const uint8_t tile_area_height = 3;	// this will allow cour18 chars to fit into the area

const u8g2_uint_t pixel_area_x_pos = tile_area_x_pos*8;
const u8g2_uint_t pixel_area_y_pos = tile_area_y_pos*8;
const u8g2_uint_t pixel_area_width = tile_area_width*8;
const u8g2_uint_t pixel_area_height = tile_area_height*8;

void setup(void) {
  u8g2.begin();
    
  u8g2.clearBuffer();					// clear the internal memory
  u8g2.setFont(u8g2_font_helvR10_tr);	// choose a suitable font
  u8g2.drawStr(0,12,""UpdateDisplayArea"");	// write something to the internal memory
  
  // draw a frame, only the content within the frame will be updated
  // the frame is never drawn again, but will stay on the display
  u8g2.drawBox(pixel_area_x_pos-1, pixel_area_y_pos-1, pixel_area_width+2, pixel_area_height+2);
  
  u8g2.sendBuffer();					// transfer internal memory to the display
  
  u8g2.setFont(u8g2_font_courB18_tr);	// set the target font for the text width calculation
  width = u8g2.getUTF8Width(text);		// calculate the pixel width of the text
  offset = width+pixel_area_width;
  
  
}

void loop(void) {
  u8g2.clearBuffer();						// clear the complete internal memory

  // draw the scrolling text at current offset
  u8g2.setFont(u8g2_font_courB18_tr);		// set the target font
  u8g2.drawUTF8(
    pixel_area_x_pos-width+offset, 
    pixel_area_y_pos+pixel_area_height+u8g2.getDescent()-1, 
    text);								// draw the scolling text
  
  // now only update the selected area, the rest of the display content is not changed
  u8g2.updateDisplayArea(tile_area_x_pos, tile_area_y_pos, tile_area_width, tile_area_height);
      
  offset--;								// scroll by one pixel
  if ( offset == 0 )	
    offset = width+pixel_area_width;			// start over again
    
  delay(10);							// do some small delay
}

",16343,True,4909.748576569494,median
"// Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)
// This is a human-readable summary of (and not a substitute for) the license.
// Disclaimer
//
// You are free to:
// Share — copy and redistribute the material in any medium or format
// Adapt — remix, transform, and build upon the material
// The licensor cannot revoke these freedoms as long as you follow the license terms.
//
// Under the following terms:
// Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
// NonCommercial — You may not use the material for commercial purposes.
// ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
// No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
//
// Notices:
// You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.
// No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.
//
// github: https://github.com/gusgonnet/minimalistThermostat
// hackster: https://www.hackster.io/gusgonnet/the-minimalist-thermostat-bb0410
//
// Free for personal use.
//
// https://creativecommons.org/licenses/by-nc-sa/4.0/

/*******************************************************************************
// ncd.io relay support, comment out if you are not using this board:
// https://store.ncd.io/product/4-channel-general-purpose-spdt-relay-shield-4-gpio-with-iot-interface/
*******************************************************************************/
// #define USE_NCD_RELAYS

/*******************************************************************************
 Here you decide if you want to use Blynk or not by 
 commenting this line ""#define USE_BLYNK"" (or not)
*******************************************************************************/
#define USE_BLYNK

/*******************************************************************************
 This activates an ssd1306 display - 128x64 oled
 Most probably this cannot be used with relays on D0 and D1!
*******************************************************************************/
// #define USE_OLED_DISPLAY

#include ""elapsedMillis.h""
#include ""PietteTech_DHT.h""
#include ""FiniteStateMachine.h""
#include ""NCD4Relay.h""

#ifdef USE_BLYNK
#include ""blynk.h""
#include ""blynkAuthToken.h""
#endif

#ifdef USE_OLED_DISPLAY
#include ""Adafruit_SSD1306.h""
#endif

#define APP_NAME ""Thermostat""
String VERSION = ""Version 0.30"";
// * BREAKING CHANGE in 0.27!!! DHT moved from D4 to D5

/*******************************************************************************
 * changes in version 0.09:
       * reorganized code to group functions
       * added minimum time to protect on-off on the fan and the heating element
          in function heatingUpdateFunction()
 * changes in version 0.10:
       * added temperatureCalibration to fix DHT measurements with existing thermostat
       * reduced END_OF_CYCLE_TIMEOUT to one sec since my HVAC controller
          takes care of running the fan for a minute to evacuate the heat/cool air
          from the vents
       * added pushbullet notifications for heating on/off
       * added fan on/off setting via a cloud function
 * changes in version 0.11:
      * added more pushbullet notifications and commented out publish() in other cases
 * changes in version 0.12:
           * added blynk support
           * added minimumIdleTimer, to protect fan and heating/cooling elements
              from glitches
 * changes in version 0.13:
           * removing endOfCycleState since my HVAC does not need it
           * adding time in notifications
 * changes in version 0.14:
           * debouncing target temp and fan status
 * changes in version 0.15:
           * taking few samples and averaging the temperature to improve stability
 * changes in version 0.16:
           * discarding samples below 0 celsius for those times when the reading of
              the temperature sensor goes wrong
           * adding date/time in notifications
           * leave only 2 decimals in temp notifications (19.00 instead of 19.000000)
           * improving blynk project
           * fine tunning the testing mode
           * adding Titan test scripts
              more info here: https://www.hackster.io/gusgonnet/how-to-test-your-projects-with-titan-a633f2
 * changes in version 0.17:
           * PUSHBULLET_NOTIF renamed to PUSHBULLET_NOTIF_PERSONAL
           * removed yyyy-mm-dd from notifications and left only hh:mm:ss
           * minor changes in temp/humidity reported with Particle.publish()
           * reporting targetTemp when desired temp is reached
 * changes in version 0.18:
           * created a pulse of heating for warming up the house a bit
           * created a function that sets the fan on and contains this code below in function myDigitalWrite()
              if (USE_BLYNK == ""yes"") {
           * updated the blynk app
           * created a mode variable (heating, cooling, off)
 * changes in version 0.19:
           * created blynk defined variables (for instance: BLYNK_LED_FAN)
           * updates in the fan control, making UI more responsive to user changes
           * add cooling support
           * pulses now are able to cool the house
 * changes in version 0.20:
           * create a state variable (idle, heating, cooling, off, fan on)
           * trying to fix bug where in init both cool and heat leads remain on until idle state is triggered
           * set the debounce timer to double the default for mode changes
 * changes in version 0.21:
           * store settings in eeprom
           * changing defaults to HVAC OFF (from HEATING)
           * updating the blynk cloud periodically
           * added in the blynk app the state of the thermostat (also published in the particle cloud)
           * here is the link for cloning the blynk app http://tinyurl.com/zq9lcef
           * changed all eeprom values to uint8_t to save space and bytes written
             this saves eeprom pages to be written more often than needed
             (for instance a float takes 4 bytes and an uint8_t takes only 1)
 * changes in version 0.22:
           * fixed an issue with targetTempString, when rebooting the photon would not show the
             temperature loaded from the eeprom
 * changes in version 0.23:
           * Swapped pushbullet notifications with google sheets on thermostat activity
                 source: https://www.hackster.io/gusgonnet/pushing-data-to-google-docs-02f9c4
 * changes in version 0.24:
           * Reverting to Heating/Cooling from Winter/Summer modes
 * changes in version 0.25:
           * updated D0/D1/D2 to D1/D2/D3 since my photon's D0 is not behaving
           * Renaming to Heat/Cool from Heating/Cooling modes
 * changes in version 0.26:
           * Particle build share link: https://go.particle.io/shared_apps/5a30567d31ef4463730008ad  
           * add multi thread support for photon: SYSTEM_THREAD(ENABLED);
           * adding support for ncd.io 4 relays board:
              https://store.ncd.io/product/4-channel-general-purpose-spdt-relay-shield-4-gpio-with-iot-interface/
           * reducing DEBOUNCE_SETTINGS to 2000
           * reducing DEBOUNCE_SETTINGS_MODE to 4000
           * changed and simplified code with
              if (USE_BLYNK == ""yes"") to #define USE_BLYNK
           * adding oled 128*64 support
 * changes in version 0.27:
           * Particle build share link: https://go.particle.io/shared_apps/5af213e3d51e93abd20003b0
           * adding setFan(), setMode() and setTargetTemp() cloud functions
           * BREAKING CHANGE!!! DHT moved from D4 to D5
 * changes in version 0.28:
           * adding watchdog
           * reset if no wifi for 2 minutes
 * changes in version 0.29:
           * decreasing temp threshold from 0.10 to 0.05
 * changes in version 0.30:
           * increasing temp threshold from 0.05 to 0.20, otherwise the heat starts and stops too soon and often

                 
TODO:
  * set max time for heating or cooling in 5 hours (alarm) or 6 hours (auto-shut-off)
  * #define STATE_FAN_ON ""Fan On"" -> the fan status should show up in the status
  * refloat BLYNK_CONNECTED()?
  * the fan goes off few seconds after the cooling is on

*******************************************************************************/

// use google sheets?
// source: https://www.hackster.io/gusgonnet/pushing-data-to-google-docs-02f9c4
// #define USE_GOOGLE_SHEETS

// use pushbullet for notifications?
// source: https://www.hackster.io/gusgonnet/sharing-the-push-notifications-of-your-hardware-b558ae
#define USE_PUSHBULLET

#ifdef USE_PUSHBULLET
#define PUSHBULLET_NOTIF_HOME ""pushbulletHOME""         //-> family group in pushbullet
#define PUSHBULLET_NOTIF_PERSONAL ""pushbulletPERSONAL"" //-> only my phone
#endif

const int TIME_ZONE = -4;

/*******************************************************************************
 initialize FSM states with proper enter, update and exit functions
*******************************************************************************/
State initState = State(initEnterFunction, initUpdateFunction, initExitFunction);
State idleState = State(idleEnterFunction, idleUpdateFunction, idleExitFunction);
State heatingState = State(heatingEnterFunction, heatingUpdateFunction, heatingExitFunction);
State pulseState = State(pulseEnterFunction, pulseUpdateFunction, pulseExitFunction);
State coolingState = State(coolingEnterFunction, coolingUpdateFunction, coolingExitFunction);

//initialize state machine, start in state: Idle
FSM thermostatStateMachine = FSM(initState);

//milliseconds for the init cycle, so temperature samples get stabilized
//this should be in the order of the 5 minutes: 5*60*1000==300000
//for now, I will use 1 minute
#define INIT_TIMEOUT 60000
elapsedMillis initTimer;

//minimum number of milliseconds to leave the heating element on
// to protect on-off on the fan and the heating/cooling elements
#define MINIMUM_ON_TIMEOUT 60000
elapsedMillis minimumOnTimer;

//minimum number of milliseconds to leave the system in idle state
// to protect the fan and the heating/cooling elements
#define MINIMUM_IDLE_TIMEOUT 60000
elapsedMillis minimumIdleTimer;

//milliseconds to pulse on the heating = 600 seconds = 10 minutes
// turns the heating on for a certain time
// comes in handy when you want to warm up the house a little bit
#define PULSE_TIMEOUT 600000
elapsedMillis pulseTimer;

/*******************************************************************************
 IO mapping
*******************************************************************************/
// D1 : relay1: fan
// D2 : relay2: heat
// D3 : relay3: cool
// D5 : DHT22
// D0, D4, D6, D7 : unused
// A0~A7 : unused
int fan = D1;
int heat = D2;
int cool = D3;
//TESTING_HACK
int fanOutput;
int heatOutput;
int coolOutput;

/*******************************************************************************
 DHT sensor
*******************************************************************************/
#define DHTTYPE DHT22            // Sensor type DHT11/21/22/AM2301/AM2302
#define DHTPIN 5                 // Digital pin for communications
#define DHT_SAMPLE_INTERVAL 5000 // Sample room temperature every 5 seconds \\
                                 //  this is then averaged in temperatureAverage
void dht_wrapper();              // must be declared before the lib initialization
PietteTech_DHT DHT(DHTPIN, DHTTYPE, dht_wrapper);
bool bDHTstarted; // flag to indicate we started acquisition
elapsedMillis dhtSampleInterval;
// how many samples to take and average, more takes longer but measurement is smoother
const int NUMBER_OF_SAMPLES = 10;
//const float DUMMY = -100;
//const float DUMMY_ARRAY[NUMBER_OF_SAMPLES] = { DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY };
#define DUMMY -100
#define DUMMY_ARRAY {DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY, DUMMY};
float temperatureSamples[NUMBER_OF_SAMPLES] = DUMMY_ARRAY;
float averageTemperature;

/*******************************************************************************
 thermostat related declarations
*******************************************************************************/
//temperature related variables - internal
float targetTemp = 19.0;
float currentTemp = 20.0;
float currentHumidity = 0.0;

//you can change this to your liking
// a smaller value will make your temperature more constant at the price of
//  starting the heat more times
// a larger value will reduce the number of times the HVAC comes on but will leave it on a longer time
float margin = 0.20;

//sensor difference with real temperature (if none set to zero)
//use this variable to align measurements with your existing thermostat
float temperatureCalibration = -1.35;

//temperature related variables - to be exposed in the cloud
String targetTempString = String(targetTemp);           //String to store the target temp so it can be exposed and set
String currentTempString = String(currentTemp);         //String to store the sensor's temp so it can be exposed
String currentHumidityString = String(currentHumidity); //String to store the sensor's humidity so it can be exposed

#define DEBOUNCE_SETTINGS 2000
#define DEBOUNCE_SETTINGS_MODE 4000 //give more time to the MODE change
float newTargetTemp = 19.0;
elapsedMillis setNewTargetTempTimer;

bool externalFan = false;
bool internalFan = false;
bool fanButtonClick = false;
elapsedMillis fanButtonClickTimer;

bool externalPulse = false;
bool internalPulse = false;
bool pulseButtonClick = false;
elapsedMillis pulseButtonClickTimer;

//here are the possible modes the thermostat can be in: off/heat/cool
#define MODE_OFF ""Off""
#define MODE_HEAT ""Heat""
#define MODE_COOL ""Cool""
String externalMode = MODE_OFF;
String internalMode = MODE_OFF;
bool modeButtonClick = false;
elapsedMillis modeButtonClickTimer;

//here are the possible states of the thermostat
#define STATE_INIT ""Initializing""
#define STATE_IDLE ""Idle""
#define STATE_HEATING ""Heating""
#define STATE_COOLING ""Cooling""
#define STATE_FAN_ON ""Fan On""
#define STATE_OFF ""Off""
#define STATE_PULSE_HEAT ""Pulse Heat""
#define STATE_PULSE_COOL ""Pulse Cool""
String state = STATE_INIT;

// timers work on millis, so we adjust the value with this constant
#define MILLISECONDS_TO_MINUTES 60000
#define MILLISECONDS_TO_SECONDS 1000

//TESTING_HACK
// this allows me to system test the project
bool testing = false;

/*******************************************************************************
 Your blynk token goes in another file to avoid sharing it by mistake
  (like I did in one of my commits some time ago)
 The file containing your blynk auth token has to be named blynkAuthToken.h and it should 
 contain something like this:
  #define BLYNK_AUTH_TOKEN ""1234567890123456789012345678901234567890""
 replace with your project auth token (the blynk app will give you one)
*******************************************************************************/
#ifdef USE_BLYNK
char auth[] = BLYNK_AUTH_TOKEN;

//definitions for the blynk interface
#define BLYNK_DISPLAY_CURRENT_TEMP V0
#define BLYNK_DISPLAY_HUMIDITY V1
#define BLYNK_DISPLAY_TARGET_TEMP V2
#define BLYNK_SLIDER_TEMP V10

#define BLYNK_BUTTON_FAN V11
#define BLYNK_LED_FAN V3
#define BLYNK_LED_HEAT V4
#define BLYNK_LED_COOL V5

#define BLYNK_DISPLAY_MODE V7
#define BLYNK_BUTTON_MODE V8
#define BLYNK_LED_PULSE V6
#define BLYNK_BUTTON_PULSE V12
#define BLYNK_DISPLAY_STATE V13

//this is the remote temperature sensor
#define BLYNK_DISPLAY_CURRENT_TEMP_UPSTAIRS V9

//this defines how often the readings are sent to the blynk cloud (millisecs)
#define BLYNK_STORE_INTERVAL 5000
elapsedMillis blynkStoreInterval;

WidgetLED fanLed(BLYNK_LED_FAN);     //register led to virtual pin 3
WidgetLED heatLed(BLYNK_LED_HEAT);   //register led to virtual pin 4
WidgetLED coolLed(BLYNK_LED_COOL);   //register led to virtual pin 5
WidgetLED pulseLed(BLYNK_LED_PULSE); //register led to virtual pin 6
#endif

//enable the user code (our program below) to run in parallel with cloud connectivity code
// source: https://docs.particle.io/reference/firmware/photon/#system-thread
SYSTEM_THREAD(ENABLED);

#ifdef USE_NCD_RELAYS
NCD4Relay relayController;
int triggerRelay(String command);

// timers for switching off the relays - the only one supported here is relay 4
// suince all others are used by the thermostat
elapsedMillis timerOnRelay4;
int turnOffRelay4AfterTime = 0;
#endif

#ifdef USE_OLED_DISPLAY
Adafruit_SSD1306 display(D4);

//this defines how often the display is updated
#define OLED_UPDATE_INTERVAL 5000
elapsedMillis oledUpdateInterval;
int oledStep = 0;

#endif

/*******************************************************************************
 structure for writing thresholds in eeprom
 https://docs.particle.io/reference/firmware/photon/#eeprom
*******************************************************************************/
//randomly chosen value here. The only thing that matters is that it's not 255
// since 255 is the default value for uninitialized eeprom
// I used 137 and 138 in version 0.21 already
#define EEPROM_VERSION 139
#define EEPROM_ADDRESS 0

struct EepromMemoryStructure
{
  uint8_t version = EEPROM_VERSION;
  uint8_t targetTemp;
  uint8_t internalFan;
  uint8_t internalMode;
};
EepromMemoryStructure eepromMemory;

bool settingsHaveChanged = false;
elapsedMillis settingsHaveChanged_timer;
#define SAVE_SETTINGS_INTERVAL 10000

// reset the system after 120 seconds if the application is unresponsive
// https://docs.particle.io/reference/device-os/firmware/photon/#application-watchdog
ApplicationWatchdog wd(120000, System.reset);

#define RESET_IF_NO_WIFI 120000
elapsedMillis resetIfNoWifiInterval;

/*******************************************************************************
 * Function Name  : setup
 * Description    : this function runs once at system boot
 *******************************************************************************/
void setup()
{

  //publish startup message with firmware version
  Particle.publish(APP_NAME, VERSION, 60, PRIVATE);

#ifdef USE_NCD_RELAYS
  Serial.begin(115200);
  relayController.setAddress(0, 0, 0);
  triggerRelay(""turnoffallrelays"");

  Particle.function(""controlRelay"", triggerRelay);
  Particle.function(""relayStatus"", relayStatus);

#else
  //declare and init pins
  pinMode(fan, OUTPUT);
  pinMode(heat, OUTPUT);
  pinMode(cool, OUTPUT);
  myDigitalWrite(fan, LOW);
  myDigitalWrite(heat, LOW);
  myDigitalWrite(cool, LOW);
#endif

  // declare cloud variables
  // https://docs.particle.io/reference/firmware/photon/#particle-variable-
  // Up to 20 cloud variables may be registered and each variable name is limited
  // to a maximum of 12 characters.
  Particle.variable(""targetTemp"", targetTempString);
  Particle.variable(""currentTemp"", currentTempString);
  Particle.variable(""humidity"", currentHumidityString);
  Particle.variable(""mode"", externalMode);
  Particle.variable(""state"", state);

  // declare cloud functions
  // https://docs.particle.io/reference/firmware/photon/#particle-function-
  // Up to 15 cloud functions may be registered and each function name is limited
  // to a maximum of 12 characters.
  Particle.function(""setTargetTmp"", setTargetTemp);
  Particle.function(""setMode"", setMode);
  Particle.function(""setFan"", setFan);
  // Particle.function(""setPulse"", setPulse);

  //TESTING_HACK
  Particle.function(""getOutputs"", getOutputs);
  // Particle.function(""setCurrTmp"", setCurrentTemp);
  // Particle.function(""setTesting"", setTesting);

#ifdef USE_BLYNK
  Blynk.begin(auth);
#endif

  Time.zone(TIME_ZONE);

  //reset samples array to default so we fill it up with new samples
  uint8_t i;
  for (i = 0; i < NUMBER_OF_SAMPLES; i++)
  {
    temperatureSamples[i] = DUMMY;
  }

#ifdef USE_OLED_DISPLAY
  setupDisplay();
#endif

  //restore settings from eeprom, if there were any saved before
  readFromEeprom();
}

// This wrapper is in charge of calling the DHT sensor lib
void dht_wrapper() { DHT.isrCallback(); }

/*******************************************************************************
 * Function Name  : loop
 * Description    : this function runs continuously while the project is running
 *******************************************************************************/
void loop()
{

  //this function reads the temperature of the DHT sensor
  readTemperature();

#ifdef USE_BLYNK
  //all the Blynk magic happens here
  Blynk.run();

  //publish readings to the blynk server every minute so the History Graph gets updated
  // even when the blynk app is not on (running) in the users phone
  updateBlynkCloud();
#endif

  updateTargetTemp();
  updateFanStatus();
  updatePulseStatus();
  updateMode();

#ifdef USE_OLED_DISPLAY
  updateDisplay();
#endif

  //this function updates the FSM
  // the FSM is the heart of the thermostat - all actions are defined by its states
  thermostatStateMachine.update();

  //every now and then we save the settings
  saveSettings();

#if PLATFORM_ID == PLATFORM_PHOTON_PRODUCTION
    resetIfNoWifi();
#endif

}


/*******************************************************************************/
/*******************************************************************************/
/*******************          CLOUD FUNCTIONS         *************************/
/*******************************************************************************/
/*******************************************************************************/

/*******************************************************************************
 * Function Name  : setFan
 * Description    : sets the target temperature of the thermostat
                    newTargetTemp has to be a valid float value, or no new target temp will be set
 * Return         : 0 if all is good, or -1 if the parameter cannot be converted to float or
                    is not in the accepted range (15<t<30 celsius)
 *******************************************************************************/
int setFan(String newFan)
{
  if (newFan.equalsIgnoreCase(""on""))
  {
    internalFan = true;
    flagSettingsHaveChanged();
    return 0;
  }

  if (newFan.equalsIgnoreCase(""off""))
  {
    internalFan = false;
    flagSettingsHaveChanged();
    return 0;
  }

  // else parameter was invalid
  return -1;

}

/*******************************************************************************
 * Function Name  : setMode
 * Description    : sets the target temperature of the thermostat
                    newTargetTemp has to be a valid float value, or no new target temp will be set
 * Return         : 0 if all is good, or -1 if the parameter cannot be converted to float or
                    is not in the accepted range (15<t<30 celsius)
 *******************************************************************************/
int setMode(String newMode)
{
  //mode: cycle through off->heating->cooling
  // do this only when blynk sends a 1
  // background: in a BLYNK push button, blynk sends 0 then 1 when user taps on it
  // source: http://docs.blynk.cc/#widgets-controllers-button
  if ( ( newMode != MODE_OFF) && ( newMode != MODE_HEAT) && ( newMode!= MODE_COOL ))
  {
    return -1;
  }

  externalMode = newMode;
  flagSettingsHaveChanged();
  return 0;

}

/*******************************************************************************
 * Function Name  : setTargetTemp
 * Description    : sets the target temperature of the thermostat
                    newTargetTemp has to be a valid float value, or no new target temp will be set
 * Return         : 0 if all is good, or -1 if the parameter cannot be converted to float or
                    is not in the accepted range (15<t<30 celsius)
 *******************************************************************************/
int setTargetTemp(String temp)
{
  float tmpFloat = temp.toFloat();
  //update the target temp only in the case the conversion to float works
  // (toFloat returns 0 if there is a problem in the conversion)
  // sorry, if you wanted to set 0 as the target temp, you can't :)
  if ((tmpFloat > 0) && (tmpFloat > 14.9) && (tmpFloat < 31))
  {
    //newTargetTemp will be copied to targetTemp moments after in function updateTargetTemp()
    // this is to 1-debounce the blynk slider I use and 2-debounce the user changing his/her mind quickly
    targetTemp = tmpFloat;
    targetTempString = float2string(targetTemp);
    flagSettingsHaveChanged();
    return 0;
  }

  //show only 2 decimals in notifications
  // Example: show 19.00 instead of 19.000000
  temp = temp.substring(0, temp.length() - 4);

  //if the execution reaches here then the value was invalid
  //Particle.publish(APP_NAME, ""ERROR: Failed to set new target temp to "" + temp, 60, PRIVATE);
  //  Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""ERROR: Failed to set new target temp to "" + temp + getTime(), 60, PRIVATE);
  String tempStatus = ""ERROR: Failed to set new target temp to "" + temp + getTime();
  publishEvent(tempStatus);
  return -1;
}



/*******************************************************************************
 * Function Name  : setTargetTempInternal
 * Description    : sets the target temperature of the thermostat
                    newTargetTemp has to be a valid float value, or no new target temp will be set
 * Behavior       : the new setting will not take place right away, but moments after
                    since a timer is triggered. This is to debounce the setting and
                    allow the users to change their mind
* Return         : 0 if all is good, or -1 if the parameter cannot be converted to float or
                    is not in the accepted range (15<t<30 celsius)
 *******************************************************************************/
int setTargetTempInternal(String temp)
{
  float tmpFloat = temp.toFloat();
  //update the target temp only in the case the conversion to float works
  // (toFloat returns 0 if there is a problem in the conversion)
  // sorry, if you wanted to set 0 as the target temp, you can't :)
  if ((tmpFloat > 0) && (tmpFloat > 14.9) && (tmpFloat < 31))
  {
    //newTargetTemp will be copied to targetTemp moments after in function updateTargetTemp()
    // this is to 1-debounce the blynk slider I use and 2-debounce the user changing his/her mind quickly
    newTargetTemp = tmpFloat;
    //start timer to debounce this new setting
    setNewTargetTempTimer = 0;
    return 0;
  }

  //show only 2 decimals in notifications
  // Example: show 19.00 instead of 19.000000
  temp = temp.substring(0, temp.length() - 4);

  //if the execution reaches here then the value was invalid
  //Particle.publish(APP_NAME, ""ERROR: Failed to set new target temp to "" + temp, 60, PRIVATE);
  //  Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""ERROR: Failed to set new target temp to "" + temp + getTime(), 60, PRIVATE);
  String tempStatus = ""ERROR: Failed to set new target temp to "" + temp + getTime();
  publishEvent(tempStatus);
  return -1;
}

/*******************************************************************************
 * Function Name  : updateTargetTemp
 * Description    : updates the value of target temperature of the thermostat
                    moments after it was set with setTargetTempInternal
 * Return         : none
 *******************************************************************************/
void updateTargetTemp()
{
  //debounce the new setting
  if (setNewTargetTempTimer < DEBOUNCE_SETTINGS)
  {
    return;
  }
  //is there anything to update?
  if (targetTemp == newTargetTemp)
  {
    return;
  }

  targetTemp = newTargetTemp;
  targetTempString = float2string(targetTemp);

  //Particle.publish(APP_NAME, ""New target temp: "" + targetTempString, 60, PRIVATE);
  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""New target temp: "" + targetTempString + ""°C"" + getTime(), 60, PRIVATE);
  String tempStatus = ""New target temp: "" + targetTempString + ""°C"" + getTime();
  publishEvent(tempStatus);
}

/*******************************************************************************
 * Function Name  : float2string
 * Description    : return the string representation of the float number
                     passed as parameter with 2 decimals
 * Return         : the string
 *******************************************************************************/
String float2string(float floatNumber)
{
  String stringNumber = String(floatNumber);

  //return only 2 decimals
  // Example: show 19.00 instead of 19.000000
  stringNumber = stringNumber.substring(0, stringNumber.length() - 4);

  return stringNumber;
}

/*******************************************************************************
 * Function Name  : updateFanStatus
 * Description    : updates the status of the fan moments after it was set
 * Return         : none
 *******************************************************************************/
void updateFanStatus()
{
  //if the button was not pressed, get out
  if (not fanButtonClick)
  {
    return;
  }

  //debounce the new setting
  if (fanButtonClickTimer < DEBOUNCE_SETTINGS)
  {
    return;
  }

  //reset flag of button pressed
  fanButtonClick = false;

  //is there anything to update?
  // this code here takes care of the users having cycled the mode to the same original value
  if (internalFan == externalFan)
  {
    return;
  }

  //update the new setting from the external to the internal variable
  internalFan = externalFan;

  if (internalFan)
  {
    //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Fan on"" + getTime(), 60, PRIVATE);
    String tempStatus = ""Fan on"" + getTime();
    publishEvent(tempStatus);
  }
  else
  {
    //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Fan off"" + getTime(), 60, PRIVATE);
    String tempStatus = ""Fan off"" + getTime();
    publishEvent(tempStatus);
  }
}

/*******************************************************************************
 * Function Name  : updatePulseStatus
 * Description    : updates the status of the pulse of the thermostat
                    moments after it was set
 * Return         : none
 *******************************************************************************/
void updatePulseStatus()
{
  //if the button was not pressed, get out
  if (not pulseButtonClick)
  {
    return;
  }

  //debounce the new setting
  if (pulseButtonClickTimer < DEBOUNCE_SETTINGS)
  {
    return;
  }

  //reset flag of button pressed
  pulseButtonClick = false;

  //is there anything to update?
  // this code here takes care of the users having cycled the mode to the same original value
  if (internalPulse == externalPulse)
  {
    return;
  }

  //update only in the case the FSM state is idleState (the thermostat is doing nothing)
  // or pulseState (a pulse is already running and the user wants to abort it)
  if (not(thermostatStateMachine.isInState(idleState) or thermostatStateMachine.isInState(pulseState)))
  {
    Particle.publish(PUSHBULLET_NOTIF_HOME, ""ERROR: You can only start a pulse in idle state"" + getTime(), 60, PRIVATE);
#ifdef USE_BLYNK
    pulseLed.off();
#endif
    return;
  }

  //update the new setting from the external to the internal variable
  internalPulse = externalPulse;
}

/*******************************************************************************
 * Function Name  : updateMode
 * Description    : check if the mode has changed
 * Behavior       : the new setting will not take place right away, but moments after
                    since a timer is triggered. This is to debounce the setting and
                    allow the users to change their mind
 * Return         : none
 *******************************************************************************/
void updateMode()
{
  //if the mode button was not pressed, get out
  if (not modeButtonClick)
  {
    return;
  }

  //debounce the new setting
  if (modeButtonClickTimer < DEBOUNCE_SETTINGS_MODE)
  {
    return;
  }

  //reset flag of button pressed
  modeButtonClick = false;

  //is there anything to update?
  // this code here takes care of the users having cycled the mode to the same original value
  if (internalMode == externalMode)
  {
    return;
  }

  //update the new mode from the external to the internal variable
  internalMode = externalMode;
  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Mode set to "" + internalMode + getTime(), 60, PRIVATE);
  String tempStatus = ""Mode set to "" + internalMode + getTime();
  publishEvent(tempStatus);
}

/*******************************************************************************
 * Function Name  : readTemperature
 * Description    : reads the temperature of the DHT22 sensor at every DHT_SAMPLE_INTERVAL
                    if testing the app, it returns right away
 * Return         : 0
 *******************************************************************************/
int readTemperature()
{

  //TESTING_HACK
  //are we testing the app? then no need to acquire from the sensor
  if (testing)
  {
    return 0;
  }

  //time is up? no, then come back later
  if (dhtSampleInterval < DHT_SAMPLE_INTERVAL)
  {
    return 0;
  }

  //time is up, reset timer
  dhtSampleInterval = 0;

  // start the sample
  if (!bDHTstarted)
  {
    DHT.acquireAndWait(5);
    bDHTstarted = true;
  }

  //still acquiring sample? go away and come back later
  if (DHT.acquiring())
  {
    return 0;
  }

  //I observed my dht22 measuring below 0 from time to time, so let's discard that sample
  if (DHT.getCelsius() < 0)
  {
    //reset the sample flag so we can take another
    bDHTstarted = false;
    return 0;
  }

  //valid sample acquired, adjust DHT difference if any
  float tmpTemperature = (float)DHT.getCelsius();
  tmpTemperature = tmpTemperature + temperatureCalibration;

  //------------------------------------------------------------------
  //let's make an average of the measured temperature
  // by taking N samples
  uint8_t i;
  for (i = 0; i < NUMBER_OF_SAMPLES; i++)
  {
    //store the sample in the next available 'slot' in the array of samples
    if (temperatureSamples[i] == DUMMY)
    {
      temperatureSamples[i] = tmpTemperature;
      break;
    }
  }

  //is the samples array full? if not, exit and get a new sample
  if (temperatureSamples[NUMBER_OF_SAMPLES - 1] == DUMMY)
  {
    return 0;
  }

  // average all the samples out
  averageTemperature = 0;
  for (i = 0; i < NUMBER_OF_SAMPLES; i++)
  {
    averageTemperature += temperatureSamples[i];
  }
  averageTemperature /= NUMBER_OF_SAMPLES;

  //reset samples array to default so we fill it up again with new samples
  for (i = 0; i < NUMBER_OF_SAMPLES; i++)
  {
    temperatureSamples[i] = DUMMY;
  }
  //------------------------------------------------------------------

  //sample acquired and averaged - go ahead and store temperature and humidity in internal variables
  publishTemperature(averageTemperature, (float)DHT.getHumidity());

  //reset the sample flag so we can take another
  bDHTstarted = false;

  return 0;
}

/*******************************************************************************
 * Function Name  : publishTemperature
 * Description    : the temperature/humidity passed as parameters get stored in internal variables
                    and then published
 * Return         : 0
 *******************************************************************************/
int publishTemperature(float temperature, float humidity)
{

  char currentTempChar[32];
  currentTemp = temperature;
  int currentTempDecimals = (currentTemp - (int)currentTemp) * 100;
  sprintf(currentTempChar, ""%0d.%d"", (int)currentTemp, currentTempDecimals);

  char currentHumidityChar[32];
  currentHumidity = humidity;
  int currentHumidityDecimals = (currentHumidity - (int)currentHumidity) * 100;
  sprintf(currentHumidityChar, ""%0d.%d"", (int)currentHumidity, currentHumidityDecimals);

  //publish readings into exposed variables
  currentTempString = String(currentTempChar);
  currentHumidityString = String(currentHumidityChar);

  //publish readings
  Particle.publish(APP_NAME, currentTempString + ""°C "" + currentHumidityString + ""%"", 60, PRIVATE);

  return 0;
}

/*******************************************************************************
********************************************************************************
********************************************************************************
 FINITE STATE MACHINE FUNCTIONS
********************************************************************************
********************************************************************************
*******************************************************************************/
void initEnterFunction()
{
  //start the timer of this cycle
  initTimer = 0;
  //set the state
  setState(STATE_INIT);
}
void initUpdateFunction()
{
  //time is up?
  if (initTimer > INIT_TIMEOUT)
  {
    thermostatStateMachine.transitionTo(idleState);
  }
}
void initExitFunction()
{
  Particle.publish(APP_NAME, ""Initialization done"", 60, PRIVATE);
}

void idleEnterFunction()
{
  //set the state
  setState(STATE_IDLE);

  //turn off the fan only if fan was not set on manually by the user
  if (internalFan == false)
  {
    myDigitalWrite(fan, LOW);
  }
  myDigitalWrite(heat, LOW);
  myDigitalWrite(cool, LOW);

  //start the minimum timer of this cycle
  minimumIdleTimer = 0;
}
void idleUpdateFunction()
{
  //set the fan output to the internalFan ONLY in this state of the FSM
  // since other states might need the fan on
  //set it off only if it was on and internalFan changed to false
  if (internalFan == false and fanOutput == HIGH)
  {
    myDigitalWrite(fan, LOW);
  }
  //set it on only if it was off and internalFan changed to true
  if (internalFan == true and fanOutput == LOW)
  {
    myDigitalWrite(fan, HIGH);
  }

  //is minimum time up? not yet, so get out of here
  if (minimumIdleTimer < MINIMUM_IDLE_TIMEOUT)
  {
    return;
  }

  //if the thermostat is OFF, there is not much to do
  if (internalMode == MODE_OFF)
  {
    if (internalPulse)
    {
      Particle.publish(PUSHBULLET_NOTIF_HOME, ""ERROR: You cannot start a pulse when the system is OFF"" + getTime(), 60, PRIVATE);
      internalPulse = false;
    }
    return;
  }

  //are we heating?
  if (internalMode == MODE_HEAT)
  {
    //if the temperature is lower than the target, transition to heatingState
    if (currentTemp <= (targetTemp - margin))
    {
      thermostatStateMachine.transitionTo(heatingState);
    }
    if (internalPulse)
    {
      thermostatStateMachine.transitionTo(pulseState);
    }
  }

  //are we cooling?
  if (internalMode == MODE_COOL)
  {
    //if the temperature is higher than the target, transition to coolingState
    if (currentTemp > (targetTemp + margin))
    {
      thermostatStateMachine.transitionTo(coolingState);
    }
    if (internalPulse)
    {
      thermostatStateMachine.transitionTo(pulseState);
    }
  }
}
void idleExitFunction()
{
}

void heatingEnterFunction()
{
  //set the state
  setState(STATE_HEATING);

  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Heat on"" + getTime(), 60, PRIVATE);
  String tempStatus = ""Heat on"" + getTime();
  publishEvent(tempStatus);
  myDigitalWrite(fan, HIGH);
  myDigitalWrite(heat, HIGH);
  myDigitalWrite(cool, LOW);

  //start the minimum timer of this cycle
  minimumOnTimer = 0;
}
void heatingUpdateFunction()
{
  //is minimum time up?
  if (minimumOnTimer < MINIMUM_ON_TIMEOUT)
  {
    //not yet, so get out of here
    return;
  }

  if (currentTemp >= (targetTemp + margin))
  {
    //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Desired temperature reached: "" + targetTempString + ""°C"" + getTime(), 60, PRIVATE);
    String tempStatus = ""Desired temperature reached: "" + targetTempString + ""°C"" + getTime();
    publishEvent(tempStatus);
    thermostatStateMachine.transitionTo(idleState);
  }

  //was the mode changed by the user? if so, go back to idleState
  if (internalMode != MODE_HEAT)
  {
    thermostatStateMachine.transitionTo(idleState);
  }
}
void heatingExitFunction()
{
  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Heat off"" + getTime(), 60, PRIVATE);
  String tempStatus = ""Heat off"" + getTime();
  publishEvent(tempStatus);
  myDigitalWrite(fan, LOW);
  myDigitalWrite(heat, LOW);
  myDigitalWrite(cool, LOW);
}

/*******************************************************************************
 * FSM state Name : pulseState
 * Description    : turns the HVAC on for a certain time
                    comes in handy when you want to warm up/cool down the house a little bit
 *******************************************************************************/
void pulseEnterFunction()
{
  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Pulse on"" + getTime(), 60, PRIVATE);
  String tempStatus = ""Pulse on"" + getTime();
  publishEvent(tempStatus);
  if (internalMode == MODE_HEAT)
  {
    myDigitalWrite(fan, HIGH);
    myDigitalWrite(heat, HIGH);
    myDigitalWrite(cool, LOW);
    //set the state
    setState(STATE_PULSE_HEAT);
  }
  else if (internalMode == MODE_COOL)
  {
    myDigitalWrite(fan, HIGH);
    myDigitalWrite(heat, LOW);
    myDigitalWrite(cool, HIGH);
    //set the state
    setState(STATE_PULSE_COOL);
  }
  //start the timer of this cycle
  pulseTimer = 0;

  //start the minimum timer of this cycle
  minimumOnTimer = 0;
}
void pulseUpdateFunction()
{
  //is minimum time up? if not, get out of here
  if (minimumOnTimer < MINIMUM_ON_TIMEOUT)
  {
    return;
  }

  //if the pulse was canceled by the user, transition to idleState
  if (not internalPulse)
  {
    thermostatStateMachine.transitionTo(idleState);
  }

  //is the time up for the pulse? if not, get out of here
  if (pulseTimer < PULSE_TIMEOUT)
  {
    return;
  }

  thermostatStateMachine.transitionTo(idleState);
}
void pulseExitFunction()
{
  internalPulse = false;
  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Pulse off"" + getTime(), 60, PRIVATE);
  String tempStatus = ""Pulse off"" + getTime();
  publishEvent(tempStatus);
  myDigitalWrite(fan, LOW);
  myDigitalWrite(heat, LOW);
  myDigitalWrite(cool, LOW);

#ifdef USE_BLYNK
  pulseLed.off();
#endif
}

/*******************************************************************************
 * FSM state Name : coolingState
 * Description    : turns the cooling element on until the desired temperature is reached
 *******************************************************************************/
void coolingEnterFunction()
{
  //set the state
  setState(STATE_COOLING);

  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Cool on"" + getTime(), 60, PRIVATE);
  String tempStatus = ""Cool on"" + getTime();
  publishEvent(tempStatus);
  myDigitalWrite(fan, HIGH);
  myDigitalWrite(heat, LOW);
  myDigitalWrite(cool, HIGH);

  //start the minimum timer of this cycle
  minimumOnTimer = 0;
}
void coolingUpdateFunction()
{
  //is minimum time up?
  if (minimumOnTimer < MINIMUM_ON_TIMEOUT)
  {
    //not yet, so get out of here
    return;
  }

  if (currentTemp <= (targetTemp - margin))
  {
    //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Desired temperature reached: "" + targetTempString + ""°C"" + getTime(), 60, PRIVATE);
    String tempStatus = ""Desired temperature reached: "" + targetTempString + ""°C"" + getTime();
    publishEvent(tempStatus);
    thermostatStateMachine.transitionTo(idleState);
  }

  //was the mode changed by the user? if so, go back to idleState
  if (internalMode != MODE_COOL)
  {
    thermostatStateMachine.transitionTo(idleState);
  }
}
void coolingExitFunction()
{
  //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""Cool off"" + getTime(), 60, PRIVATE);
  String tempStatus = ""Cool off"" + getTime();
  publishEvent(tempStatus);
  myDigitalWrite(fan, LOW);
  myDigitalWrite(heat, LOW);
  myDigitalWrite(cool, LOW);
}

/*******************************************************************************
********************************************************************************
********************************************************************************
 TESTING HACKS
********************************************************************************
********************************************************************************
*******************************************************************************/

/*******************************************************************************
 * Function Name  : setTesting
 * Description    : allows to start testing mode
                    testing mode enables an override of the temperature read
                     by the temperature sensor.
                    this is a hack that allows system testing the project
 * Return         : 0
 *******************************************************************************/
int setTesting(String test)
{
  if (test.equalsIgnoreCase(""on""))
  {
    testing = true;
  }
  else
  {
    testing = false;
  }
  return 0;
}

/*******************************************************************************
 * Function Name  : getOutputs
 * Description    : returns the outputs so we can test the program
                    this is a hack that allows me to system test the project
 * Return         : returns the outputs
 *******************************************************************************/
int getOutputs(String dummy)
{
  // int fan = D0;
  // int heat = D1;
  // int cool = D2;
  return coolOutput * 4 + heatOutput * 2 + fanOutput * 1;
}

/*******************************************************************************
 * Function Name  : setCurrentTemp
 * Description    : sets the current temperature of the thermostat
                    newCurrentTemp has to be a valid float value, or no new current temp will be set
                    this is a hack that allows me to system test the project
* Return         : 0, or -1 if it fails to convert the temp to float
 *******************************************************************************/
int setCurrentTemp(String newCurrentTemp)
{
  float tmpFloat = newCurrentTemp.toFloat();

  //update the current temp only in the case the conversion to float works
  // (toFloat returns 0 if there is a problem in the conversion)
  // sorry, if you wanted to set 0 as the current temp, you can't :)
  if (tmpFloat > 0)
  {
    currentTemp = tmpFloat;
    currentTempString = String(currentTemp);

    //show only 2 decimals in notifications
    // Example: show 19.00 instead of 19.000000
    currentTempString = currentTempString.substring(0, currentTempString.length() - 4);

    //Particle.publish(APP_NAME, ""New current temp: "" + currentTempString, 60, PRIVATE);
    //Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""New current temp: "" + currentTempString + getTime(), 60, PRIVATE);
    String tempStatus = ""New current temp: "" + currentTempString + getTime();
    publishEvent(tempStatus);
    return 0;
  }
  else
  {
    //Particle.publish(APP_NAME, ""ERROR: Failed to set new current temp to "" + newCurrentTemp, 60, PRIVATE);
    Particle.publish(PUSHBULLET_NOTIF_PERSONAL, ""ERROR: Failed to set new current temp to "" + newCurrentTemp + getTime(), 60, PRIVATE);
    return -1;
  }
}

/*******************************************************************************
 * Function Name  : myDigitalWrite
 * Description    : writes to the pin or the relayController and sets a variable to keep track
                    this is a hack that allows me to system test the project
                    and know what is the status of the outputs
 * Return         : void
 *******************************************************************************/
void myDigitalWrite(int input, int status)
{

#ifdef USE_NCD_RELAYS
  if (status == LOW)
  {
    // relayController.turnOffRelay(convertPinToRelay(input));
    relayController.turnOffRelay(input);
  }
  else
  {
    relayController.turnOnRelay(input);
  }
#else
  digitalWrite(input, status);
#endif

  if (input == fan)
  {
    fanOutput = status;

    Particle.publish(""DEBUG fan"", String(status), 60, PRIVATE);

#ifdef USE_BLYNK
    BLYNK_setFanLed(status);
#endif
  }

  if (input == heat)
  {
    heatOutput = status;
#ifdef USE_BLYNK
    BLYNK_setHeatLed(status);
#endif
  }

  if (input == cool)
  {
    coolOutput = status;
#ifdef USE_BLYNK
    BLYNK_setCoolLed(status);
#endif
  }
}

/*******************************************************************************
 * Function Name  : getTime
 * Description    : returns the time in the following format: 14:42:31
 TIME_FORMAT_ISO8601_FULL example: 2016-03-23T14:42:31-04:00
 * Return         : the time
 *******************************************************************************/
String getTime()
{
  String timeNow = Time.format(Time.now(), TIME_FORMAT_ISO8601_FULL);
  timeNow = timeNow.substring(11, timeNow.length() - 6);
  return "" "" + timeNow;
}

/*******************************************************************************
 * Function Name  : setState
 * Description    : sets the state of the system
 * Return         : none
 *******************************************************************************/
void setState(String newState)
{
  state = newState;
#ifdef USE_BLYNK
  Blynk.virtualWrite(BLYNK_DISPLAY_STATE, state);
#endif
}

/*******************************************************************************
 * Function Name  : publishEvent
 * Description    : publishes an event, to the particle console or google sheets
 * Return         : none
 *******************************************************************************/
void publishEvent(String event)
{

#ifdef USE_GOOGLE_SHEETS
  Particle.publish(""googleDocs"", ""{\\""my-name\\"":\\"""" + event + ""\\""}"", 60, PRIVATE);
#else
  Particle.publish(""event"", event, 60, PRIVATE);
#endif
}

/*******************************************************************************
 * Function Name  : convertPinToRelay
 * Description    : send in a pin, get a relay number
 * Return         : the relay number
 *******************************************************************************/
int convertPinToRelay(int pin)
{
  Particle.publish(""DEBUG convertPinToRelay"", String(pin), 60, PRIVATE);

  switch (pin)
  {
  case 1: //fan:
    return 1;
    break;
  case 2: //heat:
    return 2;
    break;
  case 3: //cool:
    return 3;
    break;
  }
}

/*******************************************************************************/
/*******************************************************************************/
/*******************          BLYNK FUNCTIONS         **************************/
/*******************************************************************************/
/*******************************************************************************/

// only include blynk related code if you are using blynk
#ifdef USE_BLYNK

/*******************************************************************************
 * Function Name  : BLYNK_READ
 * Description    : these functions are called by blynk when the blynk app wants
 to read values from the photon
 source: http://docs.blynk.cc/#blynk-main-operations-get-data-from-hardware
 *******************************************************************************/
BLYNK_READ(BLYNK_DISPLAY_CURRENT_TEMP)
{
  //this is a blynk value display
  // source: http://docs.blynk.cc/#widgets-displays-value-display
  Blynk.virtualWrite(BLYNK_DISPLAY_CURRENT_TEMP, currentTemp);
}
BLYNK_READ(BLYNK_DISPLAY_HUMIDITY)
{
  //this is a blynk value display
  // source: http://docs.blynk.cc/#widgets-displays-value-display
  Blynk.virtualWrite(BLYNK_DISPLAY_HUMIDITY, currentHumidity);
}
BLYNK_READ(BLYNK_DISPLAY_TARGET_TEMP)
{
  //this is a blynk value display
  // source: http://docs.blynk.cc/#widgets-displays-value-display
  Blynk.virtualWrite(BLYNK_DISPLAY_TARGET_TEMP, targetTemp);
}
BLYNK_READ(BLYNK_LED_FAN)
{
  //this is a blynk led
  // source: http://docs.blynk.cc/#widgets-displays-led
  if (externalFan)
  {
    fanLed.on();
  }
  else
  {
    fanLed.off();
  }
}
BLYNK_READ(BLYNK_LED_PULSE)
{
  //this is a blynk led
  // source: http://docs.blynk.cc/#widgets-displays-led
  if (externalPulse)
  {
    pulseLed.on();
  }
  else
  {
    pulseLed.off();
  }
}
BLYNK_READ(BLYNK_LED_HEAT)
{
  //this is a blynk led
  // source: http://docs.blynk.cc/#widgets-displays-led
  if (heatOutput)
  {
    heatLed.on();
  }
  else
  {
    heatLed.off();
  }
}
BLYNK_READ(BLYNK_LED_COOL)
{
  //this is a blynk led
  // source: http://docs.blynk.cc/#widgets-displays-led
  if (coolOutput)
  {
    coolLed.on();
  }
  else
  {
    coolLed.off();
  }
}
BLYNK_READ(BLYNK_DISPLAY_MODE)
{
  Blynk.virtualWrite(BLYNK_DISPLAY_MODE, externalMode);
}
BLYNK_READ(BLYNK_DISPLAY_STATE)
{
  Blynk.virtualWrite(BLYNK_DISPLAY_STATE, state);
}

/*******************************************************************************
 * Function Name  : BLYNK_WRITE
 * Description    : these functions are called by blynk when the blynk app wants
                     to write values to the photon
                    source: http://docs.blynk.cc/#blynk-main-operations-send-data-from-app-to-hardware
 *******************************************************************************/
BLYNK_WRITE(BLYNK_SLIDER_TEMP)
{
  //this is the blynk slider
  // source: http://docs.blynk.cc/#widgets-controllers-slider
  setTargetTempInternal(param.asStr());
  flagSettingsHaveChanged();
}

BLYNK_WRITE(BLYNK_BUTTON_FAN)
{
  //flip fan status, if it's on switch it off and viceversa
  // do this only when blynk sends a 1
  // background: in a BLYNK push button, blynk sends 0 then 1 when user taps on it
  // source: http://docs.blynk.cc/#widgets-controllers-button
  if (param.asInt() == 1)
  {
    externalFan = not externalFan;
    //start timer to debounce this new setting
    fanButtonClickTimer = 0;
    //flag that the button was clicked
    fanButtonClick = true;
    //update the led
    if (externalFan)
    {
      fanLed.on();
    }
    else
    {
      fanLed.off();
    }

    flagSettingsHaveChanged();
  }
}

BLYNK_WRITE(BLYNK_BUTTON_PULSE)
{
  //flip pulse status, if it's on switch it off and viceversa
  // do this only when blynk sends a 1
  // background: in a BLYNK push button, blynk sends 0 then 1 when user taps on it
  // source: http://docs.blynk.cc/#widgets-controllers-button
  if (param.asInt() == 1)
  {
    externalPulse = not externalPulse;
    //start timer to debounce this new setting
    pulseButtonClickTimer = 0;
    //flag that the button was clicked
    pulseButtonClick = true;
    //update the pulse led
    if (externalPulse)
    {
      pulseLed.on();
    }
    else
    {
      pulseLed.off();
    }
  }
}

BLYNK_WRITE(BLYNK_BUTTON_MODE)
{
  //mode: cycle through off->heating->cooling
  // do this only when blynk sends a 1
  // background: in a BLYNK push button, blynk sends 0 then 1 when user taps on it
  // source: http://docs.blynk.cc/#widgets-controllers-button
  if (param.asInt() == 1)
  {
    if (externalMode == MODE_OFF)
    {
      externalMode = MODE_HEAT;
    }
    else if (externalMode == MODE_HEAT)
    {
      externalMode = MODE_COOL;
    }
    else if (externalMode == MODE_COOL)
    {
      externalMode = MODE_OFF;
    }
    else
    {
      externalMode = MODE_OFF;
    }

    //start timer to debounce this new setting
    modeButtonClickTimer = 0;
    //flag that the button was clicked
    modeButtonClick = true;
    //update the mode indicator
    Blynk.virtualWrite(BLYNK_DISPLAY_MODE, externalMode);

    flagSettingsHaveChanged();
  }
}

/*******************************************************************************
 * Function Name  : BLYNK_setXxxLed
 * Description    : these functions are called by our program to update the status
                    of the leds in the blynk cloud and the blynk app
                    source: http://docs.blynk.cc/#blynk-main-operations-send-data-from-app-to-hardware
*******************************************************************************/
void BLYNK_setFanLed(int status)
{
  if (status)
  {
    fanLed.on();
  }
  else
  {
    fanLed.off();
  }
}

void BLYNK_setHeatLed(int status)
{
  if (status)
  {
    heatLed.on();
  }
  else
  {
    heatLed.off();
  }
}

void BLYNK_setCoolLed(int status)
{
  if (status)
  {
    coolLed.on();
  }
  else
  {
    coolLed.off();
  }
}

// BLYNK_CONNECTED() {
//   Blynk.syncVirtual(BLYNK_DISPLAY_CURRENT_TEMP);
//   Blynk.syncVirtual(BLYNK_DISPLAY_HUMIDITY);
//   Blynk.syncVirtual(BLYNK_DISPLAY_TARGET_TEMP);
//   Blynk.syncVirtual(BLYNK_LED_FAN);
//   Blynk.syncVirtual(BLYNK_LED_HEAT);
//   Blynk.syncVirtual(BLYNK_LED_COOL);
//   Blynk.syncVirtual(BLYNK_LED_PULSE);
//   Blynk.syncVirtual(BLYNK_DISPLAY_MODE);
//   // BLYNK_setFanLed(fan);
//   // BLYNK_setHeatLed(heat);
//   // BLYNK_setCoolLed(cool);
//
//   //update the mode and state indicator
//   Blynk.virtualWrite(BLYNK_DISPLAY_MODE, externalMode);
//   Blynk.virtualWrite(BLYNK_DISPLAY_STATE, state);
// }

/*******************************************************************************
 * Function Name  : updateBlynkCloud
 * Description    : publish readings to the blynk server every minute so the
                    History Graph gets updated even when
                    the blynk app is not on (running) in the users phone
 * Return         : none
 *******************************************************************************/
void updateBlynkCloud()
{

  //is it time to store in the blynk cloud? if so, do it
  if (blynkStoreInterval > BLYNK_STORE_INTERVAL)
  {

    //reset timer
    blynkStoreInterval = 0;

    //do not write the temp while the thermostat is initializing
    if (not thermostatStateMachine.isInState(initState))
    {
      Blynk.virtualWrite(BLYNK_DISPLAY_CURRENT_TEMP, currentTemp);
      Blynk.virtualWrite(BLYNK_DISPLAY_HUMIDITY, currentHumidity);
    }

    Blynk.virtualWrite(BLYNK_DISPLAY_TARGET_TEMP, targetTemp);

    if (externalPulse)
    {
      pulseLed.on();
    }
    else
    {
      pulseLed.off();
    }

    BLYNK_setFanLed(externalFan);
    BLYNK_setHeatLed(heatOutput);
    BLYNK_setCoolLed(coolOutput);

    //update the mode and state indicator
    Blynk.virtualWrite(BLYNK_DISPLAY_MODE, externalMode);
    Blynk.virtualWrite(BLYNK_DISPLAY_STATE, state);
  }
}
#endif

/*******************************************************************************/
/*******************************************************************************/
/*******************        NCD4 RELAYS FUNCTIONS      *************************/
/*******************************************************************************/
/*******************************************************************************/
#ifdef USE_NCD_RELAYS

/*******************************************************************************
 * Function Name  : relayStatus
 * Description    : this function returns 1 if the relay is on, 0 if the relay is off
                    and -1 if there is an error
 *******************************************************************************/
int relayStatus(String relay)
{
  int relayNumber = relay.substring(0, 1).toInt();
  if ((relayNumber >= 1) && (relayNumber <= 4))
  {
    return relayController.readRelayStatus(relayNumber);
  }

  return -1;
}

/*******************************************************************************
 * Function Name  : triggerRelay
 * Description    : commands accepted:
                        - turnonallrelays
                        - turnoffallrelays
                        - setBankStatus
                        - ""3on"", ""1off"" to set on/off one relay at a time
                        - ""34on"", ""12off"", ""13on"", ""13off"" to set on/off more than one relay at a time
                        - ""34on5"", ""1on3"", ""13on40"" to turn on relay(s) for a number of minutes
                          example: ""34on5"" turns relays 3 and 4 on for 5 minutes
 * Returns        : returns 1 if the command was accepted, 0 if not
 *******************************************************************************/
int triggerRelay(String command)
{
  if (command.equalsIgnoreCase(""turnoffallrelays""))
  {
    relayController.turnOffAllRelays();
    return 1;
  }

  // Relay Specific Command
  // this supports ""4on"", ""4off"" for example
  // this supports ""4on5"", ""4on40"" to turn on relay 4 for a number of minutes
  String tempCommand = command.toLowerCase();
  // this var will store the number of minutes for a relay to be on
  int timeOn = 0;
  int relayNumber1 = 0;

  //parse the first relay number
  if (firstCharIsNumber4(tempCommand))
  {
    relayNumber1 = tempCommand.substring(0, 1).toInt();
    Serial.print(""relayNumber1: "");
    Serial.println(relayNumber1);
    //then remove the first
    tempCommand = tempCommand.substring(1);
  }

  //check if next chars are equal to on, if so, check if there was a specific ON time sent
  // it would be after the on
  // example: 4on50 for turning relay 4 on for 50 minutes
  // when the program reaches this point, 4 have already been parsed
  // so here we would end up with on50
  if (tempCommand.startsWith(""on""))
  {
    //parse the digits after the on command
    timeOn = tempCommand.substring(2).toInt();
    Serial.print(""timeOn: "");
    Serial.println(timeOn);
    // set the command to be on, so the digits that came after are removed
    tempCommand = ""on"";
  }

  Serial.print(""tempCommand:"");
  Serial.print(tempCommand);
  Serial.println(""."");

  int returnValue = 0;
  int relayNumber;
  int i;

  // analize this particular relay
  relayNumber = relayNumber1;

  if (relayNumber = 4)
  {

    Particle.publish(""command/relay/minutes"", tempCommand + ""/"" + String(relayNumber) + ""/"" + String(timeOn), 60, PRIVATE);

    if (tempCommand.equalsIgnoreCase(""on""))
    {
      Serial.println(""Turning on relay"");
      relayController.turnOnRelay(relayNumber);

      // if timeOn is not zero, then turn the relay off after timeOn minutes
      if (timeOn != 0)
      {
        turnOnRelayForSomeMinutes(relayNumber, timeOn);
      }

      Serial.println(""returning"");
      returnValue = 1;
    }
    if (tempCommand.equalsIgnoreCase(""off""))
    {
      relayController.turnOffRelay(relayNumber);
      returnValue = 1;
    }
    if (tempCommand.equalsIgnoreCase(""toggle""))
    {
      relayController.toggleRelay(relayNumber);
      returnValue = 1;
    }
    if (tempCommand.equalsIgnoreCase(""momentary""))
    {
      relayController.turnOnRelay(relayNumber);
      delay(300);
      relayController.turnOffRelay(relayNumber);
      returnValue = 1;
    }
  }

  return returnValue;
}

/*******************************************************************************
 * Function Name  : firstCharIsNumber4
 * Description    : returns true if the parameter starts with a number 4
 *******************************************************************************/
bool firstCharIsNumber4(String string)
{
  if (string.startsWith(""4""))
  {
    return true;
  }
  // not a 4 digit
  return false;
}

/*******************************************************************************
 * Function Name  : turnOnRelayForSomeMinutes
 * Description    : turn a relay on for a user defined time in minutes
 *******************************************************************************/
void turnOnRelayForSomeMinutes(int relay, int timeOn)
{

  switch (relay)
  {
  case 4:
    relayController.turnOnRelay(relay);
    timerOnRelay4 = 0;
    turnOffRelay4AfterTime = timeOn * MILLISECONDS_TO_MINUTES;
    break;
  }
}

/*******************************************************************************
 * Function Name  : turnOffRelayAutomatically
 * Description    : this function checks if there is a relay to turn off automatically
 *******************************************************************************/
void turnOffRelayAutomatically()
{

  // is time up for relay4?
  if ((turnOffRelay4AfterTime != 0) && (timerOnRelay4 > turnOffRelay4AfterTime))
  {
    turnOffRelay4AfterTime = 0;
    relayController.turnOffRelay(4);
  }
}

#endif

/*******************************************************************************/
/*******************************************************************************/
/*******************           OLED FUNCTIONS          *************************/
/*******************************************************************************/
/*******************************************************************************/
#ifdef USE_OLED_DISPLAY

/*******************************************************************************
 * Function Name  : setupDisplay
 * Description    : init the display
 * Return         : none
 *******************************************************************************/
void setupDisplay()
{

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // initialize with the I2C addr 0x3c (for the 128x64)

  display.setTextSize(4);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.clearDisplay();
  display.display();
}

/*******************************************************************************
 * Function Name  : updateDisplay
 * Description    : update what is shown in the OLED display
 * Return         : none
 *******************************************************************************/
void updateDisplay()
{

  //is it time to store in the blynk cloud? if so, do it
  if (oledUpdateInterval > OLED_UPDATE_INTERVAL)
  {

    //reset timer
    oledUpdateInterval = 0;

    display.clearDisplay();
    display.setTextSize(4);
    display.setTextColor(WHITE);
    display.setCursor(0, 0);

    switch (oledStep)
    {
    // show target temp
    case 0:
      display.setTextSize(1);
      display.println(""Target temp"");
      display.setTextSize(3);
      display.print(targetTempString);
      break;
    // show current temp
    case 1:
      display.setTextSize(1);
      display.println(""Current temp"");
      display.setTextSize(3);
      display.print(currentTempString);
      break;
      // show humidity
    case 2:
      display.setTextSize(1);
      display.println(""Humidity"");
      display.setTextSize(3);
      display.print(currentHumidityString);
      break;
    }

    display.display();

    oledStep = oledStep + 1;
    if (oledStep == 3)
    {
      oledStep = 0;
    }
  }
}

#endif

/*******************************************************************************/
/*******************************************************************************/
/*******************          EEPROM FUNCTIONS         *************************/
/********  https://docs.particle.io/reference/firmware/photon/#eeprom  *********/
/*******************************************************************************/
/*******************************************************************************/

/*******************************************************************************
 * Function Name  : flagSettingsHaveChanged
 * Description    : this function gets called when the user of the blynk app
                    changes a setting. The blynk app calls the blynk cloud and in turn
                    it calls the functions BLYNK_WRITE()
 * Return         : none
 *******************************************************************************/
void flagSettingsHaveChanged()
{
  settingsHaveChanged = true;
  settingsHaveChanged_timer = 0;
}

/*******************************************************************************
 * Function Name  : readFromEeprom
 * Description    : retrieves the settings from the EEPROM memory
 * Return         : none
 *******************************************************************************/
void readFromEeprom()
{

  EepromMemoryStructure myObj;
  EEPROM.get(EEPROM_ADDRESS, myObj);

  //verify this eeprom was written before
  // if version is 255 it means the eeprom was never written in the first place, hence the
  // data just read with the previous EEPROM.get() is invalid and we will ignore it
  if (myObj.version == EEPROM_VERSION)
  {

    targetTemp = float(myObj.targetTemp);
    newTargetTemp = targetTemp;
    targetTempString = float2string(targetTemp);

    internalMode = convertIntToMode(myObj.internalMode);
    externalMode = internalMode;

    //these variables are false at boot
    if (myObj.internalFan == 1)
    {
      internalFan = true;
      externalFan = true;
    }

    // Particle.publish(APP_NAME, ""DEBUG: read settings from EEPROM: "" + String(myObj.targetTemp)
    Particle.publish(APP_NAME, ""read:"" + internalMode + ""-"" + String(internalFan) + ""-"" + String(targetTemp), 60, PRIVATE);
  }
}

/*******************************************************************************
 * Function Name  : saveSettings
 * Description    : in this function we wait a bit to give the user time
                    to adjust the right value for them and in this way we try not
                    to save in EEPROM at every little change.
                    Remember that each eeprom writing cycle is a precious and finite resource
 * Return         : none
 *******************************************************************************/
void saveSettings()
{

  //if the thermostat is initializing, get out of here
  if (thermostatStateMachine.isInState(initState))
  {
    return;
  }

  //if no settings were changed, get out of here
  if (not settingsHaveChanged)
  {
    return;
  }

  //if settings have changed, is it time to store them?
  if (settingsHaveChanged_timer < SAVE_SETTINGS_INTERVAL)
  {
    return;
  }

  //reset timer
  settingsHaveChanged_timer = 0;
  settingsHaveChanged = false;

  //store thresholds in the struct type that will be saved in the eeprom
  eepromMemory.version = EEPROM_VERSION;
  eepromMemory.targetTemp = uint8_t(targetTemp);
  eepromMemory.internalMode = convertModeToInt(internalMode);

  eepromMemory.internalFan = 0;
  if (internalFan)
  {
    eepromMemory.internalFan = 1;
  }

  //then save
  EEPROM.put(EEPROM_ADDRESS, eepromMemory);

  // Particle.publish(APP_NAME, ""stored:"" + eepromMemory.internalMode + ""-"" + String(eepromMemory.internalFan) + ""-"" + String(eepromMemory.targetTemp) , 60, PRIVATE);
  Particle.publish(APP_NAME, ""stored:"" + internalMode + ""-"" + String(internalFan) + ""-"" + String(targetTemp), 60, PRIVATE);
}

/*******************************************************************************
 * Function Name  : convertIntToMode
 * Description    : converts the int mode (saved in the eeprom) into the String mode
 * Return         : String
 *******************************************************************************/
String convertIntToMode(uint8_t mode)
{
  if (mode == 1)
  {
    return MODE_HEAT;
  }
  if (mode == 2)
  {
    return MODE_COOL;
  }

  //in all other cases
  return MODE_OFF;
}

/*******************************************************************************
 * Function Name  : convertModeToInt
 * Description    : converts the String mode into the int mode (to be saved in the eeprom)
 * Return         : String
 *******************************************************************************/
uint8_t convertModeToInt(String mode)
{
  if (mode == MODE_HEAT)
  {
    return 1;
  }
  if (mode == MODE_COOL)
  {
    return 2;
  }

  //in all other cases
  return 0;
}

/*******************************************************************************
 * Function Name  : resetIfNoWifi
 * Description    : this function resets the device if there is no wifi for more than 2 minutes
 *******************************************************************************/
#if PLATFORM_ID == PLATFORM_PHOTON_PRODUCTION
void resetIfNoWifi()
{

    // never reset if it is connected to wifi
    if (WiFi.ready())
    {
        Serial.println(""wifi detected"");
        resetIfNoWifiInterval = 0;
        return;
    }

    Serial.println(""wifi not detected"");

    // is time up? no, then come back later
    if (resetIfNoWifiInterval < RESET_IF_NO_WIFI)
    {
        return;
    }

    // it comes here if it was not connected to wifi for RESET_IF_NO_WIFI
    Serial.println(""Resetting device"");
    delay(1000);
    System.reset();
}
#endif
",16296,True,2900.63447738277,median
"/*

  DrawLog.ino
  
  Use display terminal to output text (using Arduino print)

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2018, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list


// Setup the terminal (U8G2LOG). No connection u8g2
// The size (width * height) depends on the selected font and the display

#define U8LOG_WIDTH 20
#define U8LOG_HEIGHT 6
uint8_t u8log_buffer[U8LOG_WIDTH*U8LOG_HEIGHT];
U8G2LOG u8g2log;


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  digitalWrite(10, 0);
  digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
  u8g2log.begin(U8LOG_WIDTH, U8LOG_HEIGHT, u8log_buffer);
  u8g2log.setLineHeightOffset(0);	// set extra space between lines in pixel, this can be negative
  u8g2log.setRedrawMode(0);		// 0: Update screen with newline, 1: Update screen for every char  
}

unsigned long t = 0;

// print the output of millis() to the terminal every second
void loop(void) {

  // print something on the log window
  if ( t < millis() ) {
    t = millis() + 15000;			// every 15 seconds
    u8g2log.print(""\\f"");			// \\f = form feed: clear the screen
  }
  u8g2log.print(""millis="");
  u8g2log.print(millis());
  u8g2log.print(""\\n"");
  
  // print the log window together with a title
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_6x13_tr);		// font for the title
    u8g2.setCursor(0, 13);
    u8g2.print(""Log Output: "");				// output title
    u8g2.setFont(u8g2_font_5x7_tr);			// set the font for the terminal window
    u8g2.drawLog(0, 23, u8g2log);			// draw the log content on the display
  } while ( u8g2.nextPage() );

  delay(500);

}

",16252,True,4897.012957038591,median
"/*
Feathers
Copyright 2012-2014 Joshua Tynjala. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.controls
{
	import feathers.core.FeathersControl;
	import feathers.core.IFocusDisplayObject;
	import feathers.core.PropertyProxy;
	import feathers.events.FeathersEventType;
	import feathers.utils.math.clamp;
	import feathers.utils.math.roundToNearest;

	import flash.events.TimerEvent;
	import flash.ui.Keyboard;
	import flash.utils.Timer;

	import starling.events.Event;
	import starling.events.KeyboardEvent;
	import starling.events.Touch;
	import starling.events.TouchEvent;
	import starling.events.TouchPhase;

	/**
	 * Dispatched when the stepper's value changes.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @eventType starling.events.Event.CHANGE
	 */
	[Event(name=""change"",type=""starling.events.Event"")]

	/**
	 * Select a value between a minimum and a maximum by using increment and
	 * decrement buttons or typing in a value in a text input.
	 *
	 * <p>The following example sets the stepper's values and listens for when
	 * when the value changes:</p>
	 *
	 * <listing version=""3.0"">
	 * var stepper:NumericStepper = new NumericStepper();
	 * stepper.minimum = 0;
	 * stepper.maximum = 100;
	 * stepper.step = 1;
	 * stepper.value = 12;
	 * stepper.addEventListener( Event.CHANGE, stepper_changeHandler );
	 * this.addChild( stepper );</listing>
	 *
	 * @see http://wiki.starling-framework.org/feathers/numeric-stepper
	 */
	public class NumericStepper extends FeathersControl implements IRange, IFocusDisplayObject
	{
		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_DECREMENT_BUTTON_FACTORY:String = ""decrementButtonFactory"";

		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_INCREMENT_BUTTON_FACTORY:String = ""incrementButtonFactory"";

		/**
		 * @private
		 */
		protected static const INVALIDATION_FLAG_TEXT_INPUT_FACTORY:String = ""textInputFactory"";

		/**
		 * The default value added to the <code>nameList</code> of the decrement
		 * button.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_DECREMENT_BUTTON:String = ""feathers-numeric-stepper-decrement-button"";

		/**
		 * The default value added to the <code>nameList</code> of the increment
		 * button.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_INCREMENT_BUTTON:String = ""feathers-numeric-stepper-increment-button"";

		/**
		 * The default value added to the <code>nameList</code> of the text
		 * input.
		 *
		 * @see feathers.core.IFeathersControl#nameList
		 */
		public static const DEFAULT_CHILD_NAME_TEXT_INPUT:String = ""feathers-numeric-stepper-text-input"";

		/**
		 * The decrement button will be placed on the left side of the text
		 * input and the increment button will be placed on the right side of
		 * the text input.
		 *
		 * @see #buttonLayoutMode
		 */
		public static const BUTTON_LAYOUT_MODE_SPLIT_HORIZONTAL:String = ""splitHorizontal"";

		/**
		 * The decrement button will be placed below the text input and the
		 * increment button will be placed above the text input.
		 *
		 * @see #buttonLayoutMode
		 */
		public static const BUTTON_LAYOUT_MODE_SPLIT_VERTICAL:String = ""splitVertical"";

		/**
		 * Both the decrement and increment button will be placed on the right
		 * side of the text input. The increment button will be above the
		 * decrement button.
		 *
		 * @see #buttonLayoutMode
		 */
		public static const BUTTON_LAYOUT_MODE_RIGHT_SIDE_VERTICAL:String = ""rightSideVertical"";

		/**
		 * @private
		 */
		protected static function defaultDecrementButtonFactory():Button
		{
			return new Button();
		}

		/**
		 * @private
		 */
		protected static function defaultIncrementButtonFactory():Button
		{
			return new Button();
		}

		/**
		 * @private
		 */
		protected static function defaultTextInputFactory():TextInput
		{
			return new TextInput();
		}

		/**
		 * Constructor.
		 */
		public function NumericStepper()
		{
			this.addEventListener(Event.REMOVED_FROM_STAGE, numericStepper_removedFromStageHandler);
		}

		/**
		 * The value added to the <code>nameList</code> of the decrement button. This
		 * variable is <code>protected</code> so that sub-classes can customize
		 * the decrement button name in their constructors instead of using the default
		 * name defined by <code>DEFAULT_CHILD_NAME_DECREMENT_BUTTON</code>.
		 *
		 * <p>To customize the decrement button name without subclassing, see
		 * <code>customDecrementButtonName</code>.</p>
		 *
		 * @see #customDecrementButtonName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var decrementButtonName:String = DEFAULT_CHILD_NAME_DECREMENT_BUTTON;

		/**
		 * The value added to the <code>nameList</code> of the increment button. This
		 * variable is <code>protected</code> so that sub-classes can customize
		 * the increment button name in their constructors instead of using the default
		 * name defined by <code>DEFAULT_CHILD_NAME_INCREMENT_BUTTON</code>.
		 *
		 * <p>To customize the increment button name without subclassing, see
		 * <code>customIncrementButtonName</code>.</p>
		 *
		 * @see #customIncrementButtonName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var incrementButtonName:String = DEFAULT_CHILD_NAME_INCREMENT_BUTTON;

		/**
		 * The value added to the <code>nameList</code> of the text input. This
		 * variable is <code>protected</code> so that sub-classes can customize
		 * the text input name in their constructors instead of using the default
		 * name defined by <code>DEFAULT_CHILD_NAME_TEXT_INPUT</code>.
		 *
		 * <p>To customize the text input name without subclassing, see
		 * <code>customTextInputName</code>.</p>
		 *
		 * @see #customTextInputName
		 * @see feathers.core.IFeathersControl#nameList
		 */
		protected var textInputName:String = DEFAULT_CHILD_NAME_TEXT_INPUT;

		/**
		 * The decrement button sub-component.
		 *
		 * <p>For internal use in subclasses.</p>
		 *
		 * @see #createDecrementButton()
		 */
		protected var decrementButton:Button;

		/**
		 * The increment button sub-component.
		 *
		 * <p>For internal use in subclasses.</p>
		 *
		 * @see #createIncrementButton()
		 */
		protected var incrementButton:Button;

		/**
		 * The text input sub-component.
		 *
		 * <p>For internal use in subclasses.</p>
		 *
		 * @see #createTextInput()
		 */
		protected var textInput:TextInput;

		/**
		 * @private
		 */
		protected var touchPointID:int = -1;

		/**
		 * @private
		 */
		protected var _value:Number = 0;

		/**
		 * The value of the numeric stepper, between the minimum and maximum.
		 *
		 * <p>In the following example, the value is changed to 12:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.minimum = 0;
		 * stepper.maximum = 100;
		 * stepper.step = 1;
		 * stepper.value = 12;</listing>
		 *
		 * @default 0
		 *
		 * @see #minimum
		 * @see #maximum
		 * @see #step
		 * @see #event:change
		 */
		public function get value():Number
		{
			return this._value;
		}

		/**
		 * @private
		 */
		public function set value(newValue:Number):void
		{
			if(this._step != 0 && newValue != this._maximum && newValue != this._minimum)
			{
				newValue = roundToNearest(newValue - this._minimum, this._step) + this._minimum;
			}
			newValue = clamp(newValue, this._minimum, this._maximum);
			if(this._value == newValue)
			{
				return;
			}
			this._value = newValue;
			this.invalidate(INVALIDATION_FLAG_DATA);
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _minimum:Number = 0;

		/**
		 * The numeric stepper's value will not go lower than the minimum.
		 *
		 * <p>In the following example, the minimum is changed to 0:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.minimum = 0;
		 * stepper.maximum = 100;
		 * stepper.step = 1;
		 * stepper.value = 12;</listing>
		 *
		 * @default 0
		 *
		 * @see #value
		 * @see #maximum
		 * @see #step
		 */
		public function get minimum():Number
		{
			return this._minimum;
		}

		/**
		 * @private
		 */
		public function set minimum(value:Number):void
		{
			if(this._minimum == value)
			{
				return;
			}
			this._minimum = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _maximum:Number = 0;

		/**
		 * The numeric stepper's value will not go higher than the maximum.
		 *
		 * <p>In the following example, the maximum is changed to 100:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.minimum = 0;
		 * stepper.maximum = 100;
		 * stepper.step = 1;
		 * stepper.value = 12;</listing>
		 *
		 * @default 0
		 *
		 * @see #value
		 * @see #minimum
		 * @see #step
		 */
		public function get maximum():Number
		{
			return this._maximum;
		}

		/**
		 * @private
		 */
		public function set maximum(value:Number):void
		{
			if(this._maximum == value)
			{
				return;
			}
			this._maximum = value;
			this.invalidate(INVALIDATION_FLAG_DATA);
		}

		/**
		 * @private
		 */
		protected var _step:Number = 0;

		/**
		 * As the numeric stepper's buttons are pressed, the value is snapped to
		 * a multiple of the step.
		 *
		 * <p>In the following example, the step is changed to 1:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.minimum = 0;
		 * stepper.maximum = 100;
		 * stepper.step = 1;
		 * stepper.value = 12;</listing>
		 *
		 * @default 0
		 *
		 * @see #value
		 * @see #minimum
		 * @see #maximum
		 */
		public function get step():Number
		{
			return this._step;
		}

		/**
		 * @private
		 */
		public function set step(value:Number):void
		{
			if(this._step == value)
			{
				return;
			}
			this._step = value;
		}

		/**
		 * @private
		 */
		protected var currentRepeatAction:Function;

		/**
		 * @private
		 */
		protected var _repeatTimer:Timer;

		/**
		 * @private
		 */
		protected var _repeatDelay:Number = 0.05;

		/**
		 * The time, in seconds, before actions are repeated. The first repeat
		 * happens after a delay that is five times longer than the following
		 * repeats.
		 *
		 * <p>In the following example, the slider's repeat delay is set to
		 * 500 milliseconds:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.repeatDelay = 0.5;</listing>
		 *
		 * @default 0.05
		 */
		public function get repeatDelay():Number
		{
			return this._repeatDelay;
		}

		/**
		 * @private
		 */
		public function set repeatDelay(value:Number):void
		{
			if(this._repeatDelay == value)
			{
				return;
			}
			this._repeatDelay = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _buttonLayoutMode:String = BUTTON_LAYOUT_MODE_SPLIT_HORIZONTAL;

		[Inspectable(type=""String"",enumeration=""splitHorizontal,splitVertical,rightSideVertical"")]
		/**
		 * How the buttons are positioned relative to the text input.
		 *
		 * <p>In the following example, the button layout is set to place the
		 * buttons on the right side, stacked vertically, for a desktop
		 * appearance:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.buttonLayoutMode = NumericStepper.BUTTON_LAYOUT_MODE_RIGHT_SIDE_VERTICAL;</listing>
		 *
		 * @default NumericStepper.BUTTON_LAYOUT_MODE_SPLIT_HORIZONTAL
		 *
		 * @see #BUTTON_LAYOUT_MODE_SPLIT_HORIZONTAL
		 * @see #BUTTON_LAYOUT_MODE_SPLIT_VERTICAL
		 * @see #BUTTON_LAYOUT_MODE_RIGHT_SIDE_VERTICAL
		 */
		public function get buttonLayoutMode():String
		{
			return this._buttonLayoutMode;
		}

		/**
		 * @private
		 */
		public function set buttonLayoutMode(value:String):void
		{
			if(this._buttonLayoutMode == value)
			{
				return;
			}
			this._buttonLayoutMode = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _decrementButtonFactory:Function;

		/**
		 * A function used to generate the numeric stepper's decrement button
		 * sub-component. The decrement button must be an instance of
		 * <code>Button</code>. This factory can be used to change properties on
		 * the decrement button when it is first created. For instance, if you
		 * are skinning Feathers components without a theme, you might use this
		 * factory to set skins and other styles on the decrement button.
		 *
		 * <p>The function should have the following signature:</p>
		 * <pre>function():Button</pre>
		 *
		 * <p>In the following example, a custom decrement button factory is passed
		 * to the stepper:</p>
		 *
		 * <listing version=""3.0"">
		 * slider.decrementButtonFactory = function():Button
		 * {
		 *     var button:Button = new Button();
		 *     button.defaultSkin = new Image( upTexture );
		 *     button.downSkin = new Image( downTexture );
		 *     return button;
		 * };</listing>
		 *
		 * @default null
		 *
		 * @see feathers.controls.Button
		 * @see #decrementButtonProperties
		 */
		public function get decrementButtonFactory():Function
		{
			return this._decrementButtonFactory;
		}

		/**
		 * @private
		 */
		public function set decrementButtonFactory(value:Function):void
		{
			if(this._decrementButtonFactory == value)
			{
				return;
			}
			this._decrementButtonFactory = value;
			this.invalidate(INVALIDATION_FLAG_DECREMENT_BUTTON_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customDecrementButtonName:String;

		/**
		 * A name to add to the numeric stepper's decrement button
		 * sub-component. Typically used by a theme to provide different skins
		 * to different numeric steppers.
		 *
		 * <p>In the following example, a custom decrement button name is passed
		 * to the stepper:</p>
		 *
		 * <listing version=""3.0"">
		 * slider.customDecrementButtonName = ""my-custom-decrement-button"";</listing>
		 *
		 * <p>In your theme, you can target this sub-component name to provide
		 * different skins than the default style:</p>
		 *
		 * <listing version=""3.0"">
		 * setInitializerForClass( Button, customDecrementButtonInitializer, ""my-custom-decrement-button"");</listing>
		 *
		 * @default null
		 *
		 * @see #DEFAULT_CHILD_NAME_DECREMENT_BUTTON
		 * @see feathers.core.FeathersControl#nameList
		 * @see feathers.core.DisplayListWatcher
		 * @see #decrementButtonFactory
		 * @see #decrementButtonProperties
		 */
		public function get customDecrementButtonName():String
		{
			return this._customDecrementButtonName;
		}

		/**
		 * @private
		 */
		public function set customDecrementButtonName(value:String):void
		{
			if(this._customDecrementButtonName == value)
			{
				return;
			}
			this._customDecrementButtonName = value;
			this.invalidate(INVALIDATION_FLAG_DECREMENT_BUTTON_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _decrementButtonProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to the numeric stepper's
		 * decrement button sub-component. The decrement button is a
		 * <code>feathers.controls.Button</code> instance that is created by
		 * <code>decrementButtonFactory</code>.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb which is in a <code>SimpleScrollBar</code>,
		 * which is in a <code>List</code>, you can use the following syntax:</p>
		 * <pre>list.verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * <p>Setting properties in a <code>decrementButtonFactory</code>
		 * function instead of using <code>decrementButtonProperties</code> will
		 * result in better performance.</p>
		 *
		 * <p>In the following example, the stepper's decrement button properties
		 * are updated:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.decrementButtonProperties.defaultSkin = new Image( upTexture );
		 * stepper.decrementButtonProperties.downSkin = new Image( downTexture );</listing>
		 *
		 * @default null
		 *
		 * @see #decrementButtonFactory
		 * @see feathers.controls.Button
		 */
		public function get decrementButtonProperties():Object
		{
			if(!this._decrementButtonProperties)
			{
				this._decrementButtonProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._decrementButtonProperties;
		}

		/**
		 * @private
		 */
		public function set decrementButtonProperties(value:Object):void
		{
			if(this._decrementButtonProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._decrementButtonProperties)
			{
				this._decrementButtonProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._decrementButtonProperties = PropertyProxy(value);
			if(this._decrementButtonProperties)
			{
				this._decrementButtonProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _decrementButtonLabel:String = null;

		/**
		 * The text displayed by the decrement button. Often, there is no text
		 * displayed on this button and an icon is used instead.
		 *
		 * <p>In the following example, the decrement button's label is customized:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.decrementButtonLabel = ""-"";</listing>
		 *
		 * @default null
		 */
		public function get decrementButtonLabel():String
		{
			return this._decrementButtonLabel;
		}

		/**
		 * @private
		 */
		public function set decrementButtonLabel(value:String):void
		{
			if(this._decrementButtonLabel == value)
			{
				return;
			}
			this._decrementButtonLabel = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _incrementButtonFactory:Function;

		/**
		 * A function used to generate the numeric stepper's increment button
		 * sub-component. The increment button must be an instance of
		 * <code>Button</code>. This factory can be used to change properties on
		 * the increment button when it is first created. For instance, if you
		 * are skinning Feathers components without a theme, you might use this
		 * factory to set skins and other styles on the increment button.
		 *
		 * <p>The function should have the following signature:</p>
		 * <pre>function():Button</pre>
		 *
		 * <p>In the following example, a custom increment button factory is passed
		 * to the stepper:</p>
		 *
		 * <listing version=""3.0"">
		 * slider.incrementButtonFactory = function():Button
		 * {
		 *     var button:Button = new Button();
		 *     button.defaultSkin = new Image( upTexture );
		 *     button.downSkin = new Image( downTexture );
		 *     return button;
		 * };</listing>
		 *
		 * @default null
		 *
		 * @see feathers.controls.Button
		 * @see #incrementButtonProperties
		 */
		public function get incrementButtonFactory():Function
		{
			return this._incrementButtonFactory;
		}

		/**
		 * @private
		 */
		public function set incrementButtonFactory(value:Function):void
		{
			if(this._incrementButtonFactory == value)
			{
				return;
			}
			this._incrementButtonFactory = value;
			this.invalidate(INVALIDATION_FLAG_INCREMENT_BUTTON_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customIncrementButtonName:String;

		/**
		 * A name to add to the numeric stepper's increment button
		 * sub-component. Typically used by a theme to provide different skins
		 * to different numeric steppers.
		 *
		 * <p>In the following example, a custom increment button name is passed
		 * to the stepper:</p>
		 *
		 * <listing version=""3.0"">
		 * slider.customIncrementButtonName = ""my-custom-increment-button"";</listing>
		 *
		 * <p>In your theme, you can target this sub-component name to provide
		 * different skins than the default style:</p>
		 *
		 * <listing version=""3.0"">
		 * setInitializerForClass( Button, customIncrementButtonInitializer, ""my-custom-increment-button"");</listing>
		 *
		 * @default null
		 *
		 * @see #DEFAULT_CHILD_NAME_INCREMENT_BUTTON
		 * @see feathers.core.FeathersControl#nameList
		 * @see feathers.core.DisplayListWatcher
		 * @see #incrementButtonFactory
		 * @see #incrementButtonProperties
		 */
		public function get customIncrementButtonName():String
		{
			return this._customIncrementButtonName;
		}

		/**
		 * @private
		 */
		public function set customIncrementButtonName(value:String):void
		{
			if(this._customIncrementButtonName == value)
			{
				return;
			}
			this._customIncrementButtonName = value;
			this.invalidate(INVALIDATION_FLAG_INCREMENT_BUTTON_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _incrementButtonProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to the numeric stepper's
		 * increment button sub-component. The increment button is a
		 * <code>feathers.controls.Button</code> instance that is created by
		 * <code>incrementButtonFactory</code>.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb which is in a <code>SimpleScrollBar</code>,
		 * which is in a <code>List</code>, you can use the following syntax:</p>
		 * <pre>list.verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * <p>Setting properties in a <code>incrementButtonFactory</code>
		 * function instead of using <code>incrementButtonProperties</code> will
		 * result in better performance.</p>
		 *
		 * <p>In the following example, the stepper's increment button properties
		 * are updated:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.incrementButtonProperties.defaultSkin = new Image( upTexture );
		 * stepper.incrementButtonProperties.downSkin = new Image( downTexture );</listing>
		 *
		 * @default null
		 *
		 * @see #incrementButtonFactory
		 * @see feathers.controls.Button
		 */
		public function get incrementButtonProperties():Object
		{
			if(!this._incrementButtonProperties)
			{
				this._incrementButtonProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._incrementButtonProperties;
		}

		/**
		 * @private
		 */
		public function set incrementButtonProperties(value:Object):void
		{
			if(this._incrementButtonProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._incrementButtonProperties)
			{
				this._incrementButtonProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._incrementButtonProperties = PropertyProxy(value);
			if(this._incrementButtonProperties)
			{
				this._incrementButtonProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _incrementButtonLabel:String = null;

		/**
		 * The text displayed by the increment button. Often, there is no text
		 * displayed on this button and an icon is used instead.
		 *
		 * <p>In the following example, the increment button's label is customized:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.incrementButtonLabel = ""+"";</listing>
		 *
		 * @default null
		 */
		public function get incrementButtonLabel():String
		{
			return this._incrementButtonLabel;
		}

		/**
		 * @private
		 */
		public function set incrementButtonLabel(value:String):void
		{
			if(this._incrementButtonLabel == value)
			{
				return;
			}
			this._incrementButtonLabel = value;
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected var _textInputFactory:Function;

		/**
		 * A function used to generate the numeric stepper's text input
		 * sub-component. The text input must be an instance of <code>TextInput</code>.
		 * This factory can be used to change properties on the text input when
		 * it is first created. For instance, if you are skinning Feathers
		 * components without a theme, you might use this factory to set skins
		 * and other styles on the text input.
		 *
		 * <p>The function should have the following signature:</p>
		 * <pre>function():TextInput</pre>
		 *
		 * <p>In the following example, a custom text input factory is passed
		 * to the stepper:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.textInputFactory = function():TextInput
		 * {
		 *     var textInput:TextInput = new TextInput();
		 *     textInput.backgroundSkin = new Image( texture );
		 *     return textInput;
		 * };</listing>
		 *
		 * @default null
		 *
		 * @see feathers.controls.TextInput
		 * @see #textInputProperties
		 */
		public function get textInputFactory():Function
		{
			return this._textInputFactory;
		}

		/**
		 * @private
		 */
		public function set textInputFactory(value:Function):void
		{
			if(this._textInputFactory == value)
			{
				return;
			}
			this._textInputFactory = value;
			this.invalidate(INVALIDATION_FLAG_TEXT_INPUT_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _customTextInputName:String;

		/**
		 * A name to add to the numeric stepper's text input sub-component.
		 * Typically used by a theme to provide different skins to different
		 * text inputs.
		 *
		 * <p>In the following example, a custom text input name is passed
		 * to the stepper:</p>
		 *
		 * <listing version=""3.0"">
		 * slider.customTextInputName = ""my-custom-text-input"";</listing>
		 *
		 * <p>In your theme, you can target this sub-component name to provide
		 * different skins than the default style:</p>
		 *
		 * <listing version=""3.0"">
		 * setInitializerForClass( Button, customTextInputInitializer, ""my-custom-text-input"");</listing>
		 *
		 * @default null
		 *
		 * @see #DEFAULT_CHILD_NAME_TEXT_INPUT
		 * @see feathers.core.FeathersControl#nameList
		 * @see feathers.core.DisplayListWatcher
		 * @see #textInputFactory
		 * @see #textInputProperties
		 */
		public function get customTextInputName():String
		{
			return this._customTextInputName;
		}

		/**
		 * @private
		 */
		public function set customTextInputName(value:String):void
		{
			if(this._customTextInputName == value)
			{
				return;
			}
			this._customTextInputName = value;
			this.invalidate(INVALIDATION_FLAG_TEXT_INPUT_FACTORY);
		}

		/**
		 * @private
		 */
		protected var _textInputProperties:PropertyProxy;

		/**
		 * A set of key/value pairs to be passed down to the numeric stepper's
		 * text input sub-component. The text input is a
		 * <code>feathers.controls.TextInput</code> instance that is created by
		 * <code>textInputFactory</code>.
		 *
		 * <p>If the subcomponent has its own subcomponents, their properties
		 * can be set too, using attribute <code>&#64;</code> notation. For example,
		 * to set the skin on the thumb which is in a <code>SimpleScrollBar</code>,
		 * which is in a <code>List</code>, you can use the following syntax:</p>
		 * <pre>list.verticalScrollBarProperties.&#64;thumbProperties.defaultSkin = new Image(texture);</pre>
		 *
		 * <p>Setting properties in a <code>textInputFactory</code> function
		 * instead of using <code>textInputProperties</code> will result in
		 * better performance.</p>
		 *
		 * <p>In the following example, the stepper's text input properties
		 * are updated:</p>
		 *
		 * <listing version=""3.0"">
		 * stepper.textInputProperties.backgroundSkin = new Image( texture );</listing>
		 *
		 * @default null
		 *
		 * @see #textInputFactory
		 * @see feathers.controls.TextInput
		 */
		public function get textInputProperties():Object
		{
			if(!this._textInputProperties)
			{
				this._textInputProperties = new PropertyProxy(childProperties_onChange);
			}
			return this._textInputProperties;
		}

		/**
		 * @private
		 */
		public function set textInputProperties(value:Object):void
		{
			if(this._textInputProperties == value)
			{
				return;
			}
			if(!value)
			{
				value = new PropertyProxy();
			}
			if(!(value is PropertyProxy))
			{
				const newValue:PropertyProxy = new PropertyProxy();
				for(var propertyName:String in value)
				{
					newValue[propertyName] = value[propertyName];
				}
				value = newValue;
			}
			if(this._textInputProperties)
			{
				this._textInputProperties.removeOnChangeCallback(childProperties_onChange);
			}
			this._textInputProperties = PropertyProxy(value);
			if(this._textInputProperties)
			{
				this._textInputProperties.addOnChangeCallback(childProperties_onChange);
			}
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		override protected function draw():void
		{
			const dataInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_DATA);
			const stylesInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STYLES);
			var sizeInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_SIZE);
			const stateInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_STATE);
			const decrementButtonFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_DECREMENT_BUTTON_FACTORY);
			const incrementButtonFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_INCREMENT_BUTTON_FACTORY);
			const textInputFactoryInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_TEXT_INPUT_FACTORY);
			const focusInvalid:Boolean = this.isInvalid(INVALIDATION_FLAG_FOCUS);

			if(decrementButtonFactoryInvalid)
			{
				this.createDecrementButton();
			}

			if(incrementButtonFactoryInvalid)
			{
				this.createIncrementButton();
			}

			if(textInputFactoryInvalid)
			{
				this.createTextInput();
			}

			if(decrementButtonFactoryInvalid || stylesInvalid)
			{
				this.refreshDecrementButtonStyles();
			}

			if(incrementButtonFactoryInvalid || stylesInvalid)
			{
				this.refreshIncrementButtonStyles();
			}

			if(textInputFactoryInvalid || stylesInvalid)
			{
				this.refreshTextInputStyles();
			}

			if(textInputFactoryInvalid || dataInvalid)
			{
				this.refreshTypicalText();
				this.textInput.text = this._value.toString();
			}

			if(decrementButtonFactoryInvalid || stateInvalid)
			{
				this.decrementButton.isEnabled = this._isEnabled;
			}

			if(incrementButtonFactoryInvalid || stateInvalid)
			{
				this.incrementButton.isEnabled = this._isEnabled;
			}

			if(textInputFactoryInvalid || stateInvalid)
			{
				this.textInput.isEnabled = this._isEnabled;
			}

			sizeInvalid = this.autoSizeIfNeeded() || sizeInvalid;

			if(decrementButtonFactoryInvalid || incrementButtonFactoryInvalid || textInputFactoryInvalid ||
				dataInvalid || stylesInvalid || sizeInvalid)
			{
				this.layoutChildren();
			}

			if(sizeInvalid || focusInvalid)
			{
				this.refreshFocusIndicator();
			}
		}

		/**
		 * If the component's dimensions have not been set explicitly, it will
		 * measure its content and determine an ideal size for itself. If the
		 * <code>explicitWidth</code> or <code>explicitHeight</code> member
		 * variables are set, those value will be used without additional
		 * measurement. If one is set, but not the other, the dimension with the
		 * explicit value will not be measured, but the other non-explicit
		 * dimension will still need measurement.
		 *
		 * <p>Calls <code>setSizeInternal()</code> to set up the
		 * <code>actualWidth</code> and <code>actualHeight</code> member
		 * variables used for layout.</p>
		 *
		 * <p>Meant for internal use, and subclasses may override this function
		 * with a custom implementation.</p>
		 */
		protected function autoSizeIfNeeded():Boolean
		{
			const needsWidth:Boolean = isNaN(this.explicitWidth);
			const needsHeight:Boolean = isNaN(this.explicitHeight);
			if(!needsWidth && !needsHeight)
			{
				return false;
			}

			var newWidth:Number = this.explicitWidth;
			var newHeight:Number = this.explicitHeight;

			this.decrementButton.validate();
			this.incrementButton.validate();
			const oldTextInputWidth:Number = this.textInput.width;
			const oldTextInputHeight:Number = this.textInput.height;
			if(this._buttonLayoutMode == BUTTON_LAYOUT_MODE_RIGHT_SIDE_VERTICAL)
			{
				const maxButtonWidth:Number = Math.max(this.decrementButton.width, this.incrementButton.width);
				this.textInput.minWidth = Math.max(0, this._minWidth - maxButtonWidth);
				this.textInput.maxWidth = Math.max(0, this._maxWidth - maxButtonWidth);
				this.textInput.width = Math.max(0, this.explicitWidth - maxButtonWidth)
				this.textInput.height = this.explicitHeight;
				this.textInput.validate();

				if(needsWidth)
				{
					newWidth = this.textInput.width + maxButtonWidth;
				}
				if(needsHeight)
				{
					newHeight = Math.max(this.textInput.height, this.decrementButton.height + this.incrementButton.height);
				}
			}
			else if(this._buttonLayoutMode == BUTTON_LAYOUT_MODE_SPLIT_VERTICAL)
			{
				this.textInput.minHeight = Math.max(0, this._minHeight - this.decrementButton.height - this.incrementButton.height);
				this.textInput.maxHeight = Math.max(0, this._maxHeight - this.decrementButton.height - this.incrementButton.height);
				this.textInput.height = Math.max(0, this.explicitHeight - this.decrementButton.height - this.incrementButton.height);
				this.textInput.width = this.explicitWidth;
				this.textInput.validate();

				if(needsWidth)
				{
					newWidth = Math.max(this.decrementButton.width, this.incrementButton.width, this.textInput.width);
				}
				if(needsHeight)
				{
					newHeight = this.decrementButton.height + this.textInput.height + this.incrementButton.height;
				}
			}
			else //split horizontal
			{
				this.textInput.minWidth = Math.max(0, this._minWidth - this.decrementButton.width - this.incrementButton.width);
				this.textInput.maxWidth = Math.max(0, this._maxWidth - this.decrementButton.width - this.incrementButton.width);
				this.textInput.width = Math.max(0, this.explicitWidth - this.decrementButton.width - this.incrementButton.width);
				this.textInput.height = this.explicitHeight;
				this.textInput.validate();

				if(needsWidth)
				{
					newWidth = this.decrementButton.width + this.textInput.width + this.incrementButton.width;
				}
				if(needsHeight)
				{
					newHeight = Math.max(this.decrementButton.height, this.incrementButton.height, this.textInput.height);
				}
			}

			this.textInput.width = oldTextInputWidth;
			this.textInput.height = oldTextInputHeight;
			return this.setSizeInternal(newWidth, newHeight, false);
		}

		/**
		 * @private
		 */
		protected function decrement():void
		{
			this.value -= this._step;
			if(this.textInput.isEditable)
			{
				this.validate();
				this.textInput.selectRange(0, this.textInput.text.length);
			}
		}

		/**
		 * @private
		 */
		protected function increment():void
		{
			this.value += this._step;
			if(this.textInput.isEditable)
			{
				this.validate();
				this.textInput.selectRange(0, this.textInput.text.length);
			}
		}

		/**
		 * @private
		 */
		protected function toMinimum():void
		{
			this.value = this._minimum;
			if(this.textInput.isEditable)
			{
				this.validate();
				this.textInput.selectRange(0, this.textInput.text.length);
			}
		}

		/**
		 * @private
		 */
		protected function toMaximum():void
		{
			this.value = this._maximum;
			if(this.textInput.isEditable)
			{
				this.validate();
				this.textInput.selectRange(0, this.textInput.text.length);
			}
		}

		/**
		 * Creates and adds the <code>decrementButton</code> sub-component and
		 * removes the old instance, if one exists.
		 *
		 * <p>Meant for internal use, and subclasses may override this function
		 * with a custom implementation.</p>
		 *
		 * @see #decrementButton
		 * @see #decrementButtonFactory
		 * @see #customDecrementButtonName
		 */
		protected function createDecrementButton():void
		{
			if(this.decrementButton)
			{
				this.decrementButton.removeFromParent(true);
				this.decrementButton = null;
			}

			const factory:Function = this._decrementButtonFactory != null ? this._decrementButtonFactory : defaultDecrementButtonFactory;
			const decrementButtonName:String = this._customDecrementButtonName != null ? this._customDecrementButtonName : this.decrementButtonName;
			this.decrementButton = Button(factory());
			this.decrementButton.styleNameList.add(decrementButtonName);
			this.decrementButton.addEventListener(TouchEvent.TOUCH, decrementButton_touchHandler);
			this.addChild(this.decrementButton);
		}

		/**
		 * Creates and adds the <code>incrementButton</code> sub-component and
		 * removes the old instance, if one exists.
		 *
		 * <p>Meant for internal use, and subclasses may override this function
		 * with a custom implementation.</p>
		 *
		 * @see #incrementButton
		 * @see #incrementButtonFactory
		 * @see #customIncrementButtonName
		 */
		protected function createIncrementButton():void
		{
			if(this.incrementButton)
			{
				this.incrementButton.removeFromParent(true);
				this.incrementButton = null;
			}

			const factory:Function = this._incrementButtonFactory != null ? this._incrementButtonFactory : defaultIncrementButtonFactory;
			const incrementButtonName:String = this._customIncrementButtonName != null ? this._customIncrementButtonName : this.incrementButtonName;
			this.incrementButton = Button(factory());
			this.incrementButton.styleNameList.add(incrementButtonName);
			this.incrementButton.addEventListener(TouchEvent.TOUCH, incrementButton_touchHandler);
			this.addChild(this.incrementButton);
		}

		/**
		 * Creates and adds the <code>textInput</code> sub-component and
		 * removes the old instance, if one exists.
		 *
		 * <p>Meant for internal use, and subclasses may override this function
		 * with a custom implementation.</p>
		 *
		 * @see #textInput
		 * @see #textInputFactory
		 * @see #customTextInputName
		 */
		protected function createTextInput():void
		{
			if(this.textInput)
			{
				this.textInput.removeFromParent(true);
				this.textInput = null;
			}

			const factory:Function = this._textInputFactory != null ? this._textInputFactory : defaultTextInputFactory;
			const textInputName:String = this._customTextInputName != null ? this._customTextInputName : this.textInputName;
			this.textInput = TextInput(factory());
			this.textInput.styleNameList.add(textInputName);
			this.textInput.addEventListener(FeathersEventType.ENTER, textInput_enterHandler);
			this.textInput.addEventListener(FeathersEventType.FOCUS_OUT, textInput_focusOutHandler);
			this.textInput.isFocusEnabled = this._focusManager == null;
			this.addChild(this.textInput);
		}

		/**
		 * @private
		 */
		protected function refreshDecrementButtonStyles():void
		{
			for(var propertyName:String in this._decrementButtonProperties)
			{
				if(this.decrementButton.hasOwnProperty(propertyName))
				{
					var propertyValue:Object = this._decrementButtonProperties[propertyName];
					this.decrementButton[propertyName] = propertyValue;
				}
			}
			this.decrementButton.label = this._decrementButtonLabel;
		}

		/**
		 * @private
		 */
		protected function refreshIncrementButtonStyles():void
		{
			for(var propertyName:String in this._incrementButtonProperties)
			{
				if(this.incrementButton.hasOwnProperty(propertyName))
				{
					var propertyValue:Object = this._incrementButtonProperties[propertyName];
					this.incrementButton[propertyName] = propertyValue;
				}
			}
			this.incrementButton.label = this._incrementButtonLabel;
		}

		/**
		 * @private
		 */
		protected function refreshTextInputStyles():void
		{
			for(var propertyName:String in this._textInputProperties)
			{
				if(this.textInput.hasOwnProperty(propertyName))
				{
					var propertyValue:Object = this._textInputProperties[propertyName];
					this.textInput[propertyName] = propertyValue;
				}
			}
		}

		/**
		 * @private
		 */
		protected function refreshTypicalText():void
		{
			var typicalText:String = """";
			var characterCount:int = Math.max(this._minimum.toString().length, this._maximum.toString().length);
			for(var i:int = 0; i < characterCount; i++)
			{
				typicalText += ""0"";
			}
			this.textInput.typicalText = typicalText;
		}

		/**
		 * @private
		 */
		protected function layoutChildren():void
		{
			if(this._buttonLayoutMode == BUTTON_LAYOUT_MODE_RIGHT_SIDE_VERTICAL)
			{
				const buttonHeight:Number = this.actualHeight / 2;
				this.incrementButton.y = 0;
				this.incrementButton.height = buttonHeight;
				this.incrementButton.validate();

				this.decrementButton.y = buttonHeight;
				this.decrementButton.height = buttonHeight;
				this.decrementButton.validate();

				const buttonWidth:Number = Math.max(this.decrementButton.width, this.incrementButton.width);
				const buttonX:Number = this.actualWidth - buttonWidth;
				this.decrementButton.x = buttonX;
				this.incrementButton.x = buttonX;

				this.textInput.x = 0;
				this.textInput.y = 0;
				this.textInput.width = buttonX;
				this.textInput.height = this.actualHeight;
			}
			else if(this._buttonLayoutMode == BUTTON_LAYOUT_MODE_SPLIT_VERTICAL)
			{
				this.incrementButton.x = 0;
				this.incrementButton.y = 0;
				this.incrementButton.width = this.actualWidth;
				this.incrementButton.validate();

				this.decrementButton.x = 0;
				this.decrementButton.width = this.actualWidth;
				this.decrementButton.validate();
				this.decrementButton.y = this.actualHeight - this.decrementButton.height;

				this.textInput.x = 0;
				this.textInput.y = this.incrementButton.height;
				this.textInput.width = this.actualWidth;
				this.textInput.height = Math.max(0, this.decrementButton.y - this.incrementButton.height - this.incrementButton.y);
			}
			else //split horizontal
			{
				this.decrementButton.x = 0;
				this.decrementButton.y = 0;
				this.decrementButton.height = this.actualHeight;
				this.decrementButton.validate();

				this.incrementButton.y = 0;
				this.incrementButton.height = this.actualHeight;
				this.incrementButton.validate();
				this.incrementButton.x = this.actualWidth - this.incrementButton.width;

				this.textInput.x = this.decrementButton.width;
				this.textInput.width = this.incrementButton.x - this.textInput.x;
				this.textInput.height = this.actualHeight;
			}

			//final validation to avoid juggler next frame issues
			this.textInput.validate();
		}

		/**
		 * @private
		 */
		protected function startRepeatTimer(action:Function):void
		{
			this.currentRepeatAction = action;
			if(this._repeatDelay > 0)
			{
				if(!this._repeatTimer)
				{
					this._repeatTimer = new Timer(this._repeatDelay * 1000);
					this._repeatTimer.addEventListener(TimerEvent.TIMER, repeatTimer_timerHandler);
				}
				else
				{
					this._repeatTimer.reset();
					this._repeatTimer.delay = this._repeatDelay * 1000;
				}
				this._repeatTimer.start();
			}
		}

		/**
		 * @private
		 */
		protected function parseTextInputValue():void
		{
			var newValue:Number = parseFloat(this.textInput.text);
			if(newValue == newValue) //!isNaN
			{
				this.value = newValue;
				if(this.value != newValue && !this.isInvalid(INVALIDATION_FLAG_DATA))
				{
					//if the value setter modified the new value from the text
					//input, and it returned because the modified value is equal
					//to the current value, then we need to force invalidation
					//so that the text input's text is accurate
					this.invalidate(INVALIDATION_FLAG_DATA);
				}
			}
		}

		/**
		 * @private
		 */
		protected function childProperties_onChange(proxy:PropertyProxy, name:Object):void
		{
			this.invalidate(INVALIDATION_FLAG_STYLES);
		}

		/**
		 * @private
		 */
		protected function numericStepper_removedFromStageHandler(event:Event):void
		{
			this.touchPointID = -1;
		}

		/**
		 * @private
		 */
		override protected function focusInHandler(event:Event):void
		{
			super.focusInHandler(event);
			if(this.textInput.isEditable)
			{
				this.textInput.setFocus();
				this.textInput.selectRange(0, this.textInput.text.length);
			}
			this.stage.addEventListener(KeyboardEvent.KEY_DOWN, stage_keyDownHandler);
		}

		/**
		 * @private
		 */
		override protected function focusOutHandler(event:Event):void
		{
			super.focusOutHandler(event);
			this.textInput.clearFocus();
			this.stage.removeEventListener(KeyboardEvent.KEY_DOWN, stage_keyDownHandler);
		}

		/**
		 * @private
		 */
		protected function textInput_enterHandler(event:Event):void
		{
			this.parseTextInputValue();
		}

		/**
		 * @private
		 */
		protected function textInput_focusOutHandler(event:Event):void
		{
			this.parseTextInputValue();
		}

		/**
		 * @private
		 */
		protected function decrementButton_touchHandler(event:TouchEvent):void
		{
			if(!this._isEnabled)
			{
				this.touchPointID = -1;
				return;
			}

			if(this.touchPointID >= 0)
			{
				var touch:Touch = event.getTouch(this.decrementButton, TouchPhase.ENDED, this.touchPointID);
				if(!touch)
				{
					return;
				}
				this.touchPointID = -1;
				this._repeatTimer.stop();
				this.dispatchEventWith(FeathersEventType.END_INTERACTION);
			}
			else //if we get here, we don't have a saved touch ID yet
			{
				touch = event.getTouch(this.decrementButton, TouchPhase.BEGAN);
				if(!touch)
				{
					return;
				}
				this.touchPointID = touch.id;
				this.dispatchEventWith(FeathersEventType.BEGIN_INTERACTION);
				this.decrement();
				this.startRepeatTimer(this.decrement);
			}
		}

		/**
		 * @private
		 */
		protected function incrementButton_touchHandler(event:TouchEvent):void
		{
			if(!this._isEnabled)
			{
				this.touchPointID = -1;
				return;
			}

			if(this.touchPointID >= 0)
			{
				var touch:Touch = event.getTouch(this.incrementButton, TouchPhase.ENDED, this.touchPointID);
				if(!touch)
				{
					return;
				}
				this.touchPointID = -1;
				this._repeatTimer.stop();
				this.dispatchEventWith(FeathersEventType.END_INTERACTION);
			}
			else //if we get here, we don't have a saved touch ID yet
			{
				touch = event.getTouch(this.incrementButton, TouchPhase.BEGAN);
				if(!touch)
				{
					return;
				}
				this.touchPointID = touch.id;
				this.dispatchEventWith(FeathersEventType.BEGIN_INTERACTION);
				this.increment();
				this.startRepeatTimer(this.increment);
			}
		}

		/**
		 * @private
		 */
		protected function stage_keyDownHandler(event:KeyboardEvent):void
		{
			if(event.keyCode == Keyboard.HOME)
			{
				this.toMinimum();
			}
			else if(event.keyCode == Keyboard.END)
			{
				this.toMaximum();
			}
			else if(event.keyCode == Keyboard.UP)
			{
				this.increment();
			}
			else if(event.keyCode == Keyboard.DOWN)
			{
				this.decrement();
			}
		}

		/**
		 * @private
		 */
		protected function repeatTimer_timerHandler(event:TimerEvent):void
		{
			if(this._repeatTimer.currentCount < 5)
			{
				return;
			}
			this.currentRepeatAction();
		}
	}
}
",12079,False,2471.280099066351,median
"/*
  settings.ino - user settings for Tasmota

  Copyright (C) 2020  Theo Arends

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef DOMOTICZ_UPDATE_TIMER
#define DOMOTICZ_UPDATE_TIMER       0          // [DomoticzUpdateTimer] Send relay status (0 = disable, 1 - 3600 seconds) (Optional)
#endif

#ifndef EMULATION
#define EMULATION                   EMUL_NONE  // [Emulation] Select Belkin WeMo (single relay/light) or Hue Bridge emulation (multi relay/light) (EMUL_NONE, EMUL_WEMO or EMUL_HUE)
#endif

#ifndef MTX_ADDRESS1                           // Add Display Support for up to eigth Matrices
#define MTX_ADDRESS1                0
#endif
#ifndef MTX_ADDRESS2
#define MTX_ADDRESS2                0
#endif
#ifndef MTX_ADDRESS3
#define MTX_ADDRESS3                0
#endif
#ifndef MTX_ADDRESS4
#define MTX_ADDRESS4                0
#endif
#ifndef MTX_ADDRESS5
#define MTX_ADDRESS5                0
#endif
#ifndef MTX_ADDRESS6
#define MTX_ADDRESS6                0
#endif
#ifndef MTX_ADDRESS7
#define MTX_ADDRESS7                0
#endif
#ifndef MTX_ADDRESS8
#define MTX_ADDRESS8                0
#endif

#ifndef HOME_ASSISTANT_DISCOVERY_ENABLE
#define HOME_ASSISTANT_DISCOVERY_ENABLE 0
#endif

#ifndef LATITUDE
#define LATITUDE                    48.858360  // [Latitude] Your location to be used with sunrise and sunset
#endif
#ifndef LONGITUDE
#define LONGITUDE                   2.294442   // [Longitude] Your location to be used with sunrise and sunset
#endif

#ifndef WORKING_PERIOD
#define WORKING_PERIOD              5          // Working period of the SDS Sensor, Takes a reading every X Minutes
#endif

#ifndef COLOR_TEXT
#define COLOR_TEXT                  ""#000""     // Global text color - Black
#endif
#ifndef COLOR_BACKGROUND
#define COLOR_BACKGROUND            ""#fff""     // Global background color - White
#endif
#ifndef COLOR_FORM
#define COLOR_FORM                  ""#f2f2f2""  // Form background color - Greyish
#endif
#ifndef COLOR_INPUT_TEXT
#define COLOR_INPUT_TEXT            ""#000""     // Input text color - Black
#endif
#ifndef COLOR_INPUT
#define COLOR_INPUT                 ""#fff""     // Input background color - White
#endif
#ifndef COLOR_CONSOLE_TEXT
#define COLOR_CONSOLE_TEXT          ""#000""     // Console text color - Black
#endif
#ifndef COLOR_CONSOLE
#define COLOR_CONSOLE               ""#fff""     // Console background color - White
#endif
#ifndef COLOR_TEXT_WARNING
#define COLOR_TEXT_WARNING          ""#f00""     // Warning text color - Red
#endif
#ifndef COLOR_TEXT_SUCCESS
#define COLOR_TEXT_SUCCESS          ""#008000""  // Success text color - Green
#endif
#ifndef COLOR_BUTTON_TEXT
#define COLOR_BUTTON_TEXT           ""#fff""     // Button text color - White
#endif
#ifndef COLOR_BUTTON
#define COLOR_BUTTON                ""#1fa3ec""  // Button color - Blueish
#endif
#ifndef COLOR_BUTTON_HOVER
#define COLOR_BUTTON_HOVER          ""#0e70a4""  // Button color when hovered over - Darker blueish
#endif
#ifndef COLOR_BUTTON_RESET
#define COLOR_BUTTON_RESET          ""#d43535""  // Restart/Reset/Delete button color - Redish
#endif
#ifndef COLOR_BUTTON_RESET_HOVER
#define COLOR_BUTTON_RESET_HOVER    ""#931f1f""  // Restart/Reset/Delete button color when hovered over - Darker redish
#endif
#ifndef COLOR_BUTTON_SAVE
#define COLOR_BUTTON_SAVE           ""#47c266""  // Save button color - Greenish
#endif
#ifndef COLOR_BUTTON_SAVE_HOVER
#define COLOR_BUTTON_SAVE_HOVER     ""#5aaf6f""  // Save button color when hovered over - Darker greenish
#endif
#ifndef COLOR_TIMER_TAB_TEXT
#define COLOR_TIMER_TAB_TEXT        ""#fff""     // Config timer tab text color - White
#endif
#ifndef COLOR_TIMER_TAB_BACKGROUND
#define COLOR_TIMER_TAB_BACKGROUND  ""#999""     // Config timer tab background color - Light grey
#endif
#ifndef COLOR_TITLE_TEXT
#define COLOR_TITLE_TEXT			      COLOR_TEXT // Title text color defaults to global text color either dark or light
#endif
#ifndef IR_RCV_MIN_UNKNOWN_SIZE
#define IR_RCV_MIN_UNKNOWN_SIZE     6          // Set the smallest sized ""UNKNOWN"" message packets we actually care about (default 6, max 255)
#endif
#ifndef ENERGY_OVERTEMP
#define ENERGY_OVERTEMP             90         // Overtemp in Celsius
#endif
#ifndef DEFAULT_DIMMER_MAX
#define DEFAULT_DIMMER_MAX          100
#endif
#ifndef DEFAULT_DIMMER_MIN
#define DEFAULT_DIMMER_MIN          0
#endif
#ifndef DEFAULT_LIGHT_DIMMER
#define DEFAULT_LIGHT_DIMMER        10
#endif
#ifndef DEFAULT_LIGHT_COMPONENT
#define DEFAULT_LIGHT_COMPONENT     255
#endif
#ifndef CORS_ENABLED_ALL
#define CORS_ENABLED_ALL            ""*""
#endif


enum WebColors {
  COL_TEXT, COL_BACKGROUND, COL_FORM,
  COL_INPUT_TEXT, COL_INPUT, COL_CONSOLE_TEXT, COL_CONSOLE,
  COL_TEXT_WARNING, COL_TEXT_SUCCESS,
  COL_BUTTON_TEXT, COL_BUTTON, COL_BUTTON_HOVER, COL_BUTTON_RESET, COL_BUTTON_RESET_HOVER, COL_BUTTON_SAVE, COL_BUTTON_SAVE_HOVER,
  COL_TIMER_TAB_TEXT, COL_TIMER_TAB_BACKGROUND, COL_TITLE,
  COL_LAST };

const char kWebColors[] PROGMEM =
  COLOR_TEXT ""|"" COLOR_BACKGROUND ""|"" COLOR_FORM ""|""
  COLOR_INPUT_TEXT ""|"" COLOR_INPUT ""|"" COLOR_CONSOLE_TEXT ""|"" COLOR_CONSOLE ""|""
  COLOR_TEXT_WARNING ""|"" COLOR_TEXT_SUCCESS ""|""
  COLOR_BUTTON_TEXT ""|"" COLOR_BUTTON ""|"" COLOR_BUTTON_HOVER ""|"" COLOR_BUTTON_RESET ""|"" COLOR_BUTTON_RESET_HOVER ""|"" COLOR_BUTTON_SAVE ""|"" COLOR_BUTTON_SAVE_HOVER ""|""
  COLOR_TIMER_TAB_TEXT ""|"" COLOR_TIMER_TAB_BACKGROUND ""|"" COLOR_TITLE_TEXT;

enum TasmotaSerialConfig {
  TS_SERIAL_5N1, TS_SERIAL_6N1, TS_SERIAL_7N1, TS_SERIAL_8N1,
  TS_SERIAL_5N2, TS_SERIAL_6N2, TS_SERIAL_7N2, TS_SERIAL_8N2,
  TS_SERIAL_5E1, TS_SERIAL_6E1, TS_SERIAL_7E1, TS_SERIAL_8E1,
  TS_SERIAL_5E2, TS_SERIAL_6E2, TS_SERIAL_7E2, TS_SERIAL_8E2,
  TS_SERIAL_5O1, TS_SERIAL_6O1, TS_SERIAL_7O1, TS_SERIAL_8O1,
  TS_SERIAL_5O2, TS_SERIAL_6O2, TS_SERIAL_7O2, TS_SERIAL_8O2 };

const uint8_t kTasmotaSerialConfig[] PROGMEM = {
  SERIAL_5N1, SERIAL_6N1, SERIAL_7N1, SERIAL_8N1,
  SERIAL_5N2, SERIAL_6N2, SERIAL_7N2, SERIAL_8N2,
  SERIAL_5E1, SERIAL_6E1, SERIAL_7E1, SERIAL_8E1,
  SERIAL_5E2, SERIAL_6E2, SERIAL_7E2, SERIAL_8E2,
  SERIAL_5O1, SERIAL_6O1, SERIAL_7O1, SERIAL_8O1,
  SERIAL_5O2, SERIAL_6O2, SERIAL_7O2, SERIAL_8O2
};

/*********************************************************************************************\\
 * RTC memory
\\*********************************************************************************************/

const uint16_t RTC_MEM_VALID = 0xA55A;

uint32_t rtc_settings_crc = 0;

uint32_t GetRtcSettingsCrc(void)
{
  uint32_t crc = 0;
  uint8_t *bytes = (uint8_t*)&RtcSettings;

  for (uint32_t i = 0; i < sizeof(RTCMEM); i++) {
    crc += bytes[i]*(i+1);
  }
  return crc;
}

void RtcSettingsSave(void)
{
  if (GetRtcSettingsCrc() != rtc_settings_crc) {
    RtcSettings.valid = RTC_MEM_VALID;
    ESP.rtcUserMemoryWrite(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM));
    rtc_settings_crc = GetRtcSettingsCrc();
  }
}

void RtcSettingsLoad(void)
{
  ESP.rtcUserMemoryRead(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM));  // 0x290
  if (RtcSettings.valid != RTC_MEM_VALID) {
    memset(&RtcSettings, 0, sizeof(RTCMEM));
    RtcSettings.valid = RTC_MEM_VALID;
    RtcSettings.energy_kWhtoday = Settings.energy_kWhtoday;
    RtcSettings.energy_kWhtotal = Settings.energy_kWhtotal;
    RtcSettings.energy_usage = Settings.energy_usage;
    for (uint32_t i = 0; i < MAX_COUNTERS; i++) {
      RtcSettings.pulse_counter[i] = Settings.pulse_counter[i];
    }
    RtcSettings.power = Settings.power;
    RtcSettingsSave();
  }
  rtc_settings_crc = GetRtcSettingsCrc();
}

bool RtcSettingsValid(void)
{
  return (RTC_MEM_VALID == RtcSettings.valid);
}

/********************************************************************************************/

uint32_t rtc_reboot_crc = 0;

uint32_t GetRtcRebootCrc(void)
{
  uint32_t crc = 0;
  uint8_t *bytes = (uint8_t*)&RtcReboot;

  for (uint32_t i = 0; i < sizeof(RTCRBT); i++) {
    crc += bytes[i]*(i+1);
  }
  return crc;
}

void RtcRebootSave(void)
{
  if (GetRtcRebootCrc() != rtc_reboot_crc) {
    RtcReboot.valid = RTC_MEM_VALID;
    ESP.rtcUserMemoryWrite(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT));
    rtc_reboot_crc = GetRtcRebootCrc();
  }
}

void RtcRebootReset(void)
{
  RtcReboot.fast_reboot_count = 0;
  RtcRebootSave();
}

void RtcRebootLoad(void)
{
  ESP.rtcUserMemoryRead(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT));  // 0x280
  if (RtcReboot.valid != RTC_MEM_VALID) {
    memset(&RtcReboot, 0, sizeof(RTCRBT));
    RtcReboot.valid = RTC_MEM_VALID;
//    RtcReboot.fast_reboot_count = 0;  // Explicit by memset
    RtcRebootSave();
  }
  rtc_reboot_crc = GetRtcRebootCrc();
}

bool RtcRebootValid(void)
{
  return (RTC_MEM_VALID == RtcReboot.valid);
}

/*********************************************************************************************\\
 * Config - Flash
 *
 * Tasmota 1M flash usage
 * 0x00000000 - Unzipped binary bootloader
 * 0x00001000 - Unzipped binary code start
 *    ::::
 * 0x000xxxxx - Unzipped binary code end
 * 0x000x1000 - First page used by Core OTA
 *    ::::
 * 0x000F3000 - Tasmota Quick Power Cycle counter (SETTINGS_LOCATION - CFG_ROTATES) - First four bytes only
 * 0x000F4000 - First Tasmota rotating settings page
 *    ::::
 * 0x000FA000 - Last Tasmota rotating settings page = Last page used by Core OTA
 * 0x000FB000 - Core SPIFFS end = Core EEPROM = Tasmota settings page during OTA and when no flash rotation is active (SETTINGS_LOCATION)
 * 0x000FC000 - SDK - Uses first 128 bytes for phy init data mirrored by Core in RAM. See core_esp8266_phy.cpp phy_init_data[128] = Core user_rf_cal_sector
 * 0x000FD000 - SDK - Uses scattered bytes from 0x340 (iTead use as settings storage from 0x000FD000)
 * 0x000FE000 - SDK - Uses scattered bytes from 0x340 (iTead use as mirrored settings storage from 0x000FE000)
 * 0x000FF000 - SDK - Uses at least first 32 bytes of this page - Tasmota Zigbee persistence from 0x000FF800 to 0x000FFFFF
\\*********************************************************************************************/

extern ""C"" {
#include ""spi_flash.h""
}
#include ""eboot_command.h""

#if defined(ARDUINO_ESP8266_RELEASE_2_3_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_0) || defined(ARDUINO_ESP8266_RELEASE_2_4_1) || defined(ARDUINO_ESP8266_RELEASE_2_4_2) || defined(ARDUINO_ESP8266_RELEASE_2_5_0) || defined(ARDUINO_ESP8266_RELEASE_2_5_1) || defined(ARDUINO_ESP8266_RELEASE_2_5_2)

extern ""C"" uint32_t _SPIFFS_end;
// From libraries/EEPROM/EEPROM.cpp EEPROMClass
const uint32_t SPIFFS_END = ((uint32_t)&_SPIFFS_end - 0x40200000) / SPI_FLASH_SEC_SIZE;

#else  // Core > 2.5.2 and STAGE

#if AUTOFLASHSIZE

#include ""flash_hal.h""

// From libraries/EEPROM/EEPROM.cpp EEPROMClass
const uint32_t SPIFFS_END = (FS_end - 0x40200000) / SPI_FLASH_SEC_SIZE;

#else

extern ""C"" uint32_t _FS_end;
// From libraries/EEPROM/EEPROM.cpp EEPROMClass
const uint32_t SPIFFS_END = ((uint32_t)&_FS_end - 0x40200000) / SPI_FLASH_SEC_SIZE;

#endif  // AUTOFLASHSIZE

#endif  // All cores < pre-2.6.0

// Version 4.2 config = eeprom area
const uint32_t SETTINGS_LOCATION = SPIFFS_END;  // No need for SPIFFS as it uses EEPROM area
// Version 5.2 allow for more flash space
const uint8_t CFG_ROTATES = 8;          // Number of flash sectors used (handles uploads)

uint32_t settings_location = SETTINGS_LOCATION;
uint32_t settings_crc32 = 0;
uint8_t *settings_buffer = nullptr;

/********************************************************************************************/
/*
 * Based on cores/esp8266/Updater.cpp
 */
void SetFlashModeDout(void)
{
  uint8_t *_buffer;
  uint32_t address;

  eboot_command ebcmd;
  eboot_command_read(&ebcmd);
  address = ebcmd.args[0];
  _buffer = new uint8_t[FLASH_SECTOR_SIZE];

  if (ESP.flashRead(address, (uint32_t*)_buffer, FLASH_SECTOR_SIZE)) {
    if (_buffer[2] != 3) {  // DOUT
      _buffer[2] = 3;
      if (ESP.flashEraseSector(address / FLASH_SECTOR_SIZE)) {
        ESP.flashWrite(address, (uint32_t*)_buffer, FLASH_SECTOR_SIZE);
      }
    }
  }
  delete[] _buffer;
}

bool VersionCompatible(void)
{
  if (Settings.flag3.compatibility_check) {
    return true;
  }

  eboot_command ebcmd;
  eboot_command_read(&ebcmd);
  uint32_t start_address = ebcmd.args[0];
  uint32_t end_address = start_address + (ebcmd.args[2] & 0xFFFFF000) + FLASH_SECTOR_SIZE;
  uint32_t* buffer = new uint32_t[FLASH_SECTOR_SIZE / 4];

  uint32_t version[3] = { 0 };
  bool found = false;
  for (uint32_t address = start_address; address < end_address; address = address + FLASH_SECTOR_SIZE) {
    ESP.flashRead(address, (uint32_t*)buffer, FLASH_SECTOR_SIZE);
    if ((address == start_address) && (0x1F == (buffer[0] & 0xFF))) {
      version[1] = 0xFFFFFFFF;  // Ota file is gzipped and can not be checked for compatibility
      found = true;
    } else {
      for (uint32_t i = 0; i < (FLASH_SECTOR_SIZE / 4); i++) {
        version[0] = version[1];
        version[1] = version[2];
        version[2] = buffer[i];
        if ((MARKER_START == version[0]) && (MARKER_END == version[2])) {
          found = true;
          break;
        }
      }
    }
    if (found) { break; }
  }
  delete[] buffer;

  if (!found) { version[1] = 0; }

  AddLog_P2(LOG_LEVEL_DEBUG, PSTR(""OTA: Version 0x%08X, Compatible 0x%08X""), version[1], VERSION_COMPATIBLE);

  if (version[1] < VERSION_COMPATIBLE) {
    uint32_t eboot_magic = 0;  // Abandon OTA result
    ESP.rtcUserMemoryWrite(0, (uint32_t*)&eboot_magic, sizeof(eboot_magic));
    return false;
  }

  return true;
}

void SettingsBufferFree(void)
{
  if (settings_buffer != nullptr) {
    free(settings_buffer);
    settings_buffer = nullptr;
  }
}

bool SettingsBufferAlloc(void)
{
  SettingsBufferFree();
  if (!(settings_buffer = (uint8_t *)malloc(sizeof(Settings)))) {
    AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION D_UPLOAD_ERR_2));  // Not enough (memory) space
    return false;
  }
  return true;
}

uint16_t GetCfgCrc16(uint8_t *bytes, uint32_t size)
{
  uint16_t crc = 0;

  for (uint32_t i = 0; i < size; i++) {
    if ((i < 14) || (i > 15)) { crc += bytes[i]*(i+1); }  // Skip crc
  }
  return crc;
}

uint16_t GetSettingsCrc(void)
{
  // Fix miscalculation if previous Settings was 3584 and current Settings is 4096 between 0x06060007 and 0x0606000A
  uint32_t size = ((Settings.version < 0x06060007) || (Settings.version > 0x0606000A)) ? 3584 : sizeof(SYSCFG);
  return GetCfgCrc16((uint8_t*)&Settings, size);
}

uint32_t GetCfgCrc32(uint8_t *bytes, uint32_t size)
{
  // https://create.stephan-brumme.com/crc32/#bitwise
  uint32_t crc = 0;

  while (size--) {
    crc ^= *bytes++;
    for (uint32_t j = 0; j < 8; j++) {
      crc = (crc >> 1) ^ (-int(crc & 1) & 0xEDB88320);
    }
  }
  return ~crc;
}

uint32_t GetSettingsCrc32(void)
{
  return GetCfgCrc32((uint8_t*)&Settings, sizeof(SYSCFG) -4);  // Skip crc32
}

void SettingsSaveAll(void)
{
  if (Settings.flag.save_state) {
    Settings.power = power;
  } else {
    Settings.power = 0;
  }
  XsnsCall(FUNC_SAVE_BEFORE_RESTART);
  XdrvCall(FUNC_SAVE_BEFORE_RESTART);
  SettingsSave(0);
}

/*********************************************************************************************\\
 * Quick power cycle monitoring
\\*********************************************************************************************/

void UpdateQuickPowerCycle(bool update)
{
  if (Settings.flag3.fast_power_cycle_disable) { return; }

  uint32_t pc_register;
  uint32_t pc_location = SETTINGS_LOCATION - CFG_ROTATES;

  ESP.flashRead(pc_location * SPI_FLASH_SEC_SIZE, (uint32*)&pc_register, sizeof(pc_register));
  if (update && ((pc_register & 0xFFFFFFF0) == 0xFFA55AB0)) {
    uint32_t counter = ((pc_register & 0xF) << 1) & 0xF;
    if (0 == counter) {  // 4 power cycles in a row
      SettingsErase(3);  // Quickly reset all settings including QuickPowerCycle flag
      EspRestart();      // And restart
    } else {
      pc_register = 0xFFA55AB0 | counter;
      ESP.flashWrite(pc_location * SPI_FLASH_SEC_SIZE, (uint32*)&pc_register, sizeof(pc_register));
      AddLog_P2(LOG_LEVEL_DEBUG, PSTR(""QPC: Flag %02X""), counter);
    }
  }
  else if (pc_register != 0xFFA55ABF) {
    pc_register = 0xFFA55ABF;
    // Assume flash is default all ones and setting a bit to zero does not need an erase
    if (ESP.flashEraseSector(pc_location)) {
      ESP.flashWrite(pc_location * SPI_FLASH_SEC_SIZE, (uint32*)&pc_register, sizeof(pc_register));
    }
    AddLog_P2(LOG_LEVEL_DEBUG, PSTR(""QPC: Reset""));
  }
}

/*********************************************************************************************\\
 * Config Settings.text char array support
\\*********************************************************************************************/

uint32_t GetSettingsTextLen(void)
{
  char* position = Settings.text_pool;
  for (uint32_t size = 0; size < SET_MAX; size++) {
    while (*position++ != '\\0') { }
  }
  return position - Settings.text_pool;
}

bool SettingsUpdateText(uint32_t index, const char* replace_me)
{
  if (index >= SET_MAX) {
    return false;  // Setting not supported - internal error
  }

  // Make a copy first in case we use source from Settings.text
  uint32_t replace_len = strlen(replace_me);
  char replace[replace_len +1];
  memcpy(replace, replace_me, sizeof(replace));

  uint32_t start_pos = 0;
  uint32_t end_pos = 0;
  char* position = Settings.text_pool;
  for (uint32_t size = 0; size < SET_MAX; size++) {
    while (*position++ != '\\0') { }
    if (1 == index) {
      start_pos = position - Settings.text_pool;
    }
    else if (0 == index) {
      end_pos = position - Settings.text_pool -1;
    }
    index--;
  }
  uint32_t char_len = position - Settings.text_pool;

  uint32_t current_len = end_pos - start_pos;
  int diff = replace_len - current_len;

//  AddLog_P2(LOG_LEVEL_DEBUG, PSTR(""TST: start %d, end %d, len %d, current %d, replace %d, diff %d""),
//    start_pos, end_pos, char_len, current_len, replace_len, diff);

  int too_long = (char_len + diff) - settings_text_size;
  if (too_long > 0) {
    AddLog_P2(LOG_LEVEL_INFO, PSTR(D_LOG_CONFIG ""Text overflow by %d char(s)""), too_long);
    return false;  // Replace text too long
  }

  if (diff != 0) {
    // Shift Settings.text up or down
    memmove_P(Settings.text_pool + start_pos + replace_len, Settings.text_pool + end_pos, char_len - end_pos);
  }
  // Replace text
  memmove_P(Settings.text_pool + start_pos, replace, replace_len);
  // Fill for future use
  memset(Settings.text_pool + char_len + diff, 0x00, settings_text_size - char_len - diff);

  AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_CONFIG ""CR %d/%d""), GetSettingsTextLen(), settings_text_size);

  return true;
}

char* SettingsText(uint32_t index)
{
  char* position = Settings.text_pool;

  if (index >= SET_MAX) {
    position += settings_text_size -1;  // Setting not supported - internal error - return empty string
  } else {
    for (;index > 0; index--) {
      while (*position++ != '\\0') { }
    }
  }
  return position;
}

/*********************************************************************************************\\
 * Config Save - Save parameters to Flash ONLY if any parameter has changed
\\*********************************************************************************************/

uint32_t GetSettingsAddress(void)
{
  return settings_location * SPI_FLASH_SEC_SIZE;
}

void SettingsSave(uint8_t rotate)
{
/* Save configuration in eeprom or one of 7 slots below
 *
 * rotate 0 = Save in next flash slot
 * rotate 1 = Save only in eeprom flash slot until SetOption12 0 or restart
 * rotate 2 = Save in eeprom flash slot, erase next flash slots and continue depending on stop_flash_rotate
 * stop_flash_rotate 0 = Allow flash slot rotation (SetOption12 0)
 * stop_flash_rotate 1 = Allow only eeprom flash slot use (SetOption12 1)
 */
#ifndef FIRMWARE_MINIMAL
  if ((GetSettingsCrc32() != settings_crc32) || rotate) {
    if (1 == rotate) {   // Use eeprom flash slot only and disable flash rotate from now on (upgrade)
      stop_flash_rotate = 1;
    }
    if (2 == rotate) {   // Use eeprom flash slot and erase next flash slots if stop_flash_rotate is off (default)
      settings_location = SETTINGS_LOCATION +1;
    }
    if (stop_flash_rotate) {
      settings_location = SETTINGS_LOCATION;
    } else {
      settings_location--;
      if (settings_location <= (SETTINGS_LOCATION - CFG_ROTATES)) {
        settings_location = SETTINGS_LOCATION;
      }
    }

    Settings.save_flag++;
    if (UtcTime() > START_VALID_TIME) {
      Settings.cfg_timestamp = UtcTime();
    } else {
      Settings.cfg_timestamp++;
    }
    Settings.cfg_size = sizeof(SYSCFG);
    Settings.cfg_crc = GetSettingsCrc();  // Keep for backward compatibility in case of fall-back just after upgrade
    Settings.cfg_crc32 = GetSettingsCrc32();

    if (ESP.flashEraseSector(settings_location)) {
      ESP.flashWrite(settings_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG));
    }

    if (!stop_flash_rotate && rotate) {
      for (uint32_t i = 1; i < CFG_ROTATES; i++) {
        ESP.flashEraseSector(settings_location -i);  // Delete previous configurations by resetting to 0xFF
        delay(1);
      }
    }

    AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_CONFIG D_SAVED_TO_FLASH_AT "" %X, "" D_COUNT "" %d, "" D_BYTES "" %d""), settings_location, Settings.save_flag, sizeof(SYSCFG));

    settings_crc32 = Settings.cfg_crc32;
  }
#endif  // FIRMWARE_MINIMAL
  RtcSettingsSave();
}

void SettingsLoad(void)
{
  // Load configuration from eeprom or one of 7 slots below if first valid load does not stop_flash_rotate
  struct SYSCFGH {
    uint16_t cfg_holder;                     // 000
    uint16_t cfg_size;                       // 002
    unsigned long save_flag;                 // 004
  } _SettingsH;
  unsigned long save_flag = 0;

  settings_location = 0;
  uint32_t flash_location = SETTINGS_LOCATION +1;
  uint16_t cfg_holder = 0;
  for (uint32_t i = 0; i < CFG_ROTATES; i++) {
    flash_location--;
    ESP.flashRead(flash_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG));

    bool valid = false;
    if (Settings.version > 0x06000000) {
      bool almost_valid = (Settings.cfg_crc32 == GetSettingsCrc32());
      if (Settings.version < 0x0606000B) {
        almost_valid = (Settings.cfg_crc == GetSettingsCrc());
      }
      // Sometimes CRC on pages below FB, overwritten by OTA, is fine but Settings are still invalid. So check cfg_holder too
      if (almost_valid && (0 == cfg_holder)) { cfg_holder = Settings.cfg_holder; }  // At FB always active cfg_holder
      valid = (cfg_holder == Settings.cfg_holder);
    } else {
      ESP.flashRead((flash_location -1) * SPI_FLASH_SEC_SIZE, (uint32*)&_SettingsH, sizeof(SYSCFGH));
      valid = (Settings.cfg_holder == _SettingsH.cfg_holder);
    }
    if (valid) {
      if (Settings.save_flag > save_flag) {
        save_flag = Settings.save_flag;
        settings_location = flash_location;
        if (Settings.flag.stop_flash_rotate && (0 == i)) {  // Stop only if eeprom area should be used and it is valid
          break;
        }
      }
    }

    delay(1);
  }
  if (settings_location > 0) {
    ESP.flashRead(settings_location * SPI_FLASH_SEC_SIZE, (uint32*)&Settings, sizeof(SYSCFG));
    AddLog_P2(LOG_LEVEL_NONE, PSTR(D_LOG_CONFIG D_LOADED_FROM_FLASH_AT "" %X, "" D_COUNT "" %lu""), settings_location, Settings.save_flag);
  }

#ifndef FIRMWARE_MINIMAL
  if (!settings_location || (Settings.cfg_holder != (uint16_t)CFG_HOLDER)) {  // Init defaults if cfg_holder differs from user settings in my_user_config.h
    SettingsDefault();
  }
  settings_crc32 = GetSettingsCrc32();
#endif  // FIRMWARE_MINIMAL

  RtcSettingsLoad();
}

void EspErase(uint32_t start_sector, uint32_t end_sector)
{
  bool serial_output = (LOG_LEVEL_DEBUG_MORE <= seriallog_level);
  for (uint32_t sector = start_sector; sector < end_sector; sector++) {

    bool result = ESP.flashEraseSector(sector);  // Arduino core - erases flash as seen by SDK
//    bool result = !SPIEraseSector(sector);       // SDK - erases flash as seen by SDK
//    bool result = EsptoolEraseSector(sector);    // Esptool - erases flash completely (slow)

    if (serial_output) {
#ifdef ARDUINO_ESP8266_RELEASE_2_3_0
      Serial.printf(D_LOG_APPLICATION D_ERASED_SECTOR "" %d %s\\n"", sector, (result) ? D_OK : D_ERROR);
#else
      Serial.printf_P(PSTR(D_LOG_APPLICATION D_ERASED_SECTOR "" %d %s\\n""), sector, (result) ? D_OK : D_ERROR);
#endif
      delay(10);
    } else {
      yield();
    }
    OsWatchLoop();
  }
}

void SettingsErase(uint8_t type)
{
  /*
    For Arduino core and SDK:
    Erase only works from flash start address to SDK recognized flash end address (flashchip->chip_size = ESP.getFlashChipSize).
    Addresses above SDK recognized size (up to ESP.getFlashChipRealSize) are not accessable.
    For Esptool:
    The only way to erase whole flash is esptool which uses direct SPI writes to flash.

    The default erase function is EspTool (EsptoolErase)

    0 = Erase from program end until end of flash as seen by SDK
    1 = Erase 16k SDK parameter area near end of flash as seen by SDK (0x0xFCxxx - 0x0xFFFFF) solving possible wifi errors
    2 = Erase Tasmota parameter area (0x0xF3xxx - 0x0xFBFFF)
    3 = Erase Tasmota and SDK parameter area (0x0F3xxx - 0x0FFFFF)
    4 = Erase SDK parameter area used for wifi calibration (0x0FCxxx - 0x0FCFFF)
  */

#ifndef FIRMWARE_MINIMAL
  uint32_t _sectorStart = (ESP.getSketchSize() / SPI_FLASH_SEC_SIZE) + 1;
  uint32_t _sectorEnd = ESP.getFlashChipRealSize() / SPI_FLASH_SEC_SIZE;  // Flash size as reported by hardware
  if (1 == type) {
    // source Esp.cpp and core_esp8266_phy.cpp
    _sectorStart = (ESP.getFlashChipSize() / SPI_FLASH_SEC_SIZE) - 4;     // SDK parameter area
  }
  else if (2 == type) {
    _sectorStart = SETTINGS_LOCATION - CFG_ROTATES;                       // Tasmota parameter area (0x0F3xxx - 0x0FBFFF)
    _sectorEnd = SETTINGS_LOCATION +1;
  }
  else if (3 == type) {
    _sectorStart = SETTINGS_LOCATION - CFG_ROTATES;                       // Tasmota and SDK parameter area (0x0F3xxx - 0x0FFFFF)
    _sectorEnd = ESP.getFlashChipSize() / SPI_FLASH_SEC_SIZE;             // Flash size as seen by SDK
  }
  else if (4 == type) {
//    _sectorStart = (ESP.getFlashChipSize() / SPI_FLASH_SEC_SIZE) - 4;     // SDK phy area and Core calibration sector (0x0FC000)
    _sectorStart = SETTINGS_LOCATION +1;                                  // SDK phy area and Core calibration sector (0x0FC000)
    _sectorEnd = _sectorStart +1;                                         // SDK end of phy area and Core calibration sector (0x0FCFFF)
  }
/*
  else if (5 == type) {
    _sectorStart = (ESP.getFlashChipRealSize() / SPI_FLASH_SEC_SIZE) -4;  // SDK phy area and Core calibration sector (0xxFC000)
    _sectorEnd = _sectorStart +1;                                         // SDK end of phy area and Core calibration sector (0xxFCFFF)
  }
*/
  else {
    return;
  }

  AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION D_ERASE "" from 0x%08X to 0x%08X""), _sectorStart * SPI_FLASH_SEC_SIZE, (_sectorEnd * SPI_FLASH_SEC_SIZE) -1);

//  EspErase(_sectorStart, _sectorEnd);                                     // Arduino core and SDK - erases flash as seen by SDK
  EsptoolErase(_sectorStart, _sectorEnd);                                 // Esptool - erases flash completely
#endif  // FIRMWARE_MINIMAL
}

void SettingsSdkErase(void)
{
  WiFi.disconnect(false);    // Delete SDK wifi config
  SettingsErase(1);
  delay(1000);
}

/********************************************************************************************/

void SettingsDefault(void)
{
  AddLog_P(LOG_LEVEL_NONE, PSTR(D_LOG_CONFIG D_USE_DEFAULTS));
  SettingsDefaultSet1();
  SettingsDefaultSet2();
  SettingsSave(2);
}

void SettingsDefaultSet1(void)
{
  memset(&Settings, 0x00, sizeof(SYSCFG));

  Settings.cfg_holder = (uint16_t)CFG_HOLDER;
  Settings.cfg_size = sizeof(SYSCFG);
//  Settings.save_flag = 0;
  Settings.version = VERSION;
//  Settings.bootcount = 0;
//  Settings.cfg_crc = 0;
}

void SettingsDefaultSet2(void)
{
  memset((char*)&Settings +16, 0x00, sizeof(SYSCFG) -16);

  Settings.flag.stop_flash_rotate = APP_FLASH_CYCLE;
  Settings.flag.global_state = APP_ENABLE_LEDLINK;
  Settings.flag3.sleep_normal = APP_NORMAL_SLEEP;
  Settings.flag3.no_power_feedback = APP_NO_RELAY_SCAN;
  Settings.flag3.fast_power_cycle_disable = APP_DISABLE_POWERCYCLE;
  Settings.flag3.bootcount_update = DEEPSLEEP_BOOTCOUNT;
  Settings.flag3.compatibility_check = OTA_COMPATIBILITY;
  Settings.save_data = SAVE_DATA;
  Settings.param[P_BACKLOG_DELAY] = MIN_BACKLOG_DELAY;
  Settings.param[P_BOOT_LOOP_OFFSET] = BOOT_LOOP_OFFSET;  // SetOption36
  Settings.param[P_RGB_REMAP] = RGB_REMAP_RGBW;
  Settings.sleep = APP_SLEEP;
  if (Settings.sleep < 50) {
    Settings.sleep = 50;                // Default to 50 for sleep, for now
  }

  // Module
//  Settings.flag.interlock = 0;
  Settings.interlock[0] = 0xFF;         // Legacy support using all relays in one interlock group
  Settings.module = MODULE;
  ModuleDefault(WEMOS);
//  for (uint32_t i = 0; i < sizeof(Settings.my_gp); i++) { Settings.my_gp.io[i] = GPIO_NONE; }
  SettingsUpdateText(SET_FRIENDLYNAME1, FRIENDLY_NAME);
  SettingsUpdateText(SET_FRIENDLYNAME2, FRIENDLY_NAME""2"");
  SettingsUpdateText(SET_FRIENDLYNAME3, FRIENDLY_NAME""3"");
  SettingsUpdateText(SET_FRIENDLYNAME4, FRIENDLY_NAME""4"");
  SettingsUpdateText(SET_OTAURL, OTA_URL);

  // Power
  Settings.flag.save_state = SAVE_STATE;
  Settings.power = APP_POWER;
  Settings.poweronstate = APP_POWERON_STATE;
  Settings.blinktime = APP_BLINKTIME;
  Settings.blinkcount = APP_BLINKCOUNT;
  Settings.ledstate = APP_LEDSTATE;
  Settings.ledmask = APP_LEDMASK;
  Settings.pulse_timer[0] = APP_PULSETIME;
//  for (uint32_t i = 1; i < MAX_PULSETIMERS; i++) { Settings.pulse_timer[i] = 0; }

  // Serial
  Settings.serial_config = TS_SERIAL_8N1;
  Settings.baudrate = APP_BAUDRATE / 300;
  Settings.sbaudrate = SOFT_BAUDRATE / 300;
  Settings.serial_delimiter = 0xff;
  Settings.seriallog_level = SERIAL_LOG_LEVEL;

  // Wifi
  Settings.flag3.use_wifi_scan = WIFI_SCAN_AT_RESTART;
  Settings.flag3.use_wifi_rescan = WIFI_SCAN_REGULARLY;
  Settings.wifi_output_power = 170;
  ParseIp(&Settings.ip_address[0], WIFI_IP_ADDRESS);
  ParseIp(&Settings.ip_address[1], WIFI_GATEWAY);
  ParseIp(&Settings.ip_address[2], WIFI_SUBNETMASK);
  ParseIp(&Settings.ip_address[3], WIFI_DNS);
  Settings.sta_config = WIFI_CONFIG_TOOL;
//  Settings.sta_active = 0;
  SettingsUpdateText(SET_STASSID1, STA_SSID1);
  SettingsUpdateText(SET_STASSID2, STA_SSID2);
  SettingsUpdateText(SET_STAPWD1, STA_PASS1);
  SettingsUpdateText(SET_STAPWD2, STA_PASS2);
  SettingsUpdateText(SET_HOSTNAME, WIFI_HOSTNAME);

  // Syslog
  SettingsUpdateText(SET_SYSLOG_HOST, SYS_LOG_HOST);
  Settings.syslog_port = SYS_LOG_PORT;
  Settings.syslog_level = SYS_LOG_LEVEL;

  // Webserver
  Settings.flag2.emulation = EMULATION;
  Settings.flag3.gui_hostname_ip = GUI_SHOW_HOSTNAME;
  Settings.flag3.mdns_enabled = MDNS_ENABLED;
  Settings.webserver = WEB_SERVER;
  Settings.weblog_level = WEB_LOG_LEVEL;
  SettingsUpdateText(SET_WEBPWD, WEB_PASSWORD);
  SettingsUpdateText(SET_CORS, CORS_DOMAIN);

  // Button
  Settings.flag.button_restrict = KEY_DISABLE_MULTIPRESS;
  Settings.flag.button_swap = KEY_SWAP_DOUBLE_PRESS;
  Settings.flag.button_single = KEY_ONLY_SINGLE_PRESS;
  Settings.param[P_HOLD_TIME] = KEY_HOLD_TIME;  // Default 4 seconds hold time

  // Switch
  for (uint32_t i = 0; i < MAX_SWITCHES; i++) { Settings.switchmode[i] = SWITCH_MODE; }

  // MQTT
  Settings.flag.mqtt_enabled = MQTT_USE;
  Settings.flag.mqtt_response = MQTT_RESULT_COMMAND;
  Settings.flag.mqtt_offline = MQTT_LWT_MESSAGE;
  Settings.flag.mqtt_power_retain = MQTT_POWER_RETAIN;
  Settings.flag.mqtt_button_retain = MQTT_BUTTON_RETAIN;
  Settings.flag.mqtt_switch_retain = MQTT_SWITCH_RETAIN;
  Settings.flag.mqtt_sensor_retain = MQTT_SENSOR_RETAIN;
//  Settings.flag.mqtt_serial = 0;
  Settings.flag.device_index_enable = MQTT_POWER_FORMAT;
  Settings.flag3.time_append_timezone = MQTT_APPEND_TIMEZONE;
  Settings.flag3.button_switch_force_local = MQTT_BUTTON_SWITCH_FORCE_LOCAL;
  Settings.flag3.no_hold_retain = MQTT_NO_HOLD_RETAIN;
  Settings.flag3.use_underscore = MQTT_INDEX_SEPARATOR;
  Settings.flag3.grouptopic_mode = MQTT_GROUPTOPIC_FORMAT;
  SettingsUpdateText(SET_MQTT_HOST, MQTT_HOST);
  Settings.mqtt_port = MQTT_PORT;
  SettingsUpdateText(SET_MQTT_CLIENT, MQTT_CLIENT_ID);
  SettingsUpdateText(SET_MQTT_USER, MQTT_USER);
  SettingsUpdateText(SET_MQTT_PWD, MQTT_PASS);
  SettingsUpdateText(SET_MQTT_TOPIC, MQTT_TOPIC);
  SettingsUpdateText(SET_MQTT_BUTTON_TOPIC, MQTT_BUTTON_TOPIC);
  SettingsUpdateText(SET_MQTT_SWITCH_TOPIC, MQTT_SWITCH_TOPIC);
  SettingsUpdateText(SET_MQTT_GRP_TOPIC, MQTT_GRPTOPIC);
  SettingsUpdateText(SET_MQTT_FULLTOPIC, MQTT_FULLTOPIC);
  Settings.mqtt_retry = MQTT_RETRY_SECS;
  SettingsUpdateText(SET_MQTTPREFIX1, SUB_PREFIX);
  SettingsUpdateText(SET_MQTTPREFIX2, PUB_PREFIX);
  SettingsUpdateText(SET_MQTTPREFIX3, PUB_PREFIX2);
  SettingsUpdateText(SET_STATE_TXT1, MQTT_STATUS_OFF);
  SettingsUpdateText(SET_STATE_TXT2, MQTT_STATUS_ON);
  SettingsUpdateText(SET_STATE_TXT3, MQTT_CMND_TOGGLE);
  SettingsUpdateText(SET_STATE_TXT4, MQTT_CMND_HOLD);
  char fingerprint[60];
  strlcpy(fingerprint, MQTT_FINGERPRINT1, sizeof(fingerprint));
  char *p = fingerprint;
  for (uint32_t i = 0; i < 20; i++) {
    Settings.mqtt_fingerprint[0][i] = strtol(p, &p, 16);
  }
  strlcpy(fingerprint, MQTT_FINGERPRINT2, sizeof(fingerprint));
  p = fingerprint;
  for (uint32_t i = 0; i < 20; i++) {
    Settings.mqtt_fingerprint[1][i] = strtol(p, &p, 16);
  }
  Settings.tele_period = TELE_PERIOD;
  Settings.mqttlog_level = MQTT_LOG_LEVEL;

  // Energy
  Settings.flag.no_power_on_check = ENERGY_VOLTAGE_ALWAYS;
  Settings.flag2.current_resolution = 3;
//  Settings.flag2.voltage_resolution = 0;
//  Settings.flag2.wattage_resolution = 0;
  Settings.flag2.energy_resolution = ENERGY_RESOLUTION;
  Settings.flag3.dds2382_model = ENERGY_DDS2382_MODE;
  Settings.flag3.hardware_energy_total = ENERGY_HARDWARE_TOTALS;
  Settings.param[P_MAX_POWER_RETRY] = MAX_POWER_RETRY;
//  Settings.energy_power_delta = 0;
  Settings.energy_power_calibration = HLW_PREF_PULSE;
  Settings.energy_voltage_calibration = HLW_UREF_PULSE;
  Settings.energy_current_calibration = HLW_IREF_PULSE;
//  Settings.energy_kWhtoday = 0;
//  Settings.energy_kWhyesterday = 0;
//  Settings.energy_kWhdoy = 0;
//  Settings.energy_min_power = 0;
//  Settings.energy_max_power = 0;
//  Settings.energy_min_voltage = 0;
//  Settings.energy_max_voltage = 0;
//  Settings.energy_min_current = 0;
//  Settings.energy_max_current = 0;
//  Settings.energy_max_power_limit = 0;                            // MaxPowerLimit
  Settings.energy_max_power_limit_hold = MAX_POWER_HOLD;
  Settings.energy_max_power_limit_window = MAX_POWER_WINDOW;
//  Settings.energy_max_power_safe_limit = 0;                       // MaxSafePowerLimit
  Settings.energy_max_power_safe_limit_hold = SAFE_POWER_HOLD;
  Settings.energy_max_power_safe_limit_window = SAFE_POWER_WINDOW;
//  Settings.energy_max_energy = 0;                                 // MaxEnergy
//  Settings.energy_max_energy_start = 0;                           // MaxEnergyStart
//  Settings.energy_kWhtotal = 0;
  RtcSettings.energy_kWhtotal = 0;
//  memset((char*)&Settings.energy_usage, 0x00, sizeof(Settings.energy_usage));
  memset((char*)&RtcSettings.energy_usage, 0x00, sizeof(RtcSettings.energy_usage));
  Settings.param[P_OVER_TEMP] = ENERGY_OVERTEMP;

  // IRRemote
  Settings.flag.ir_receive_decimal = IR_DATA_RADIX;
  Settings.flag3.receive_raw = IR_ADD_RAW_DATA;
  Settings.param[P_IR_UNKNOW_THRESHOLD] = IR_RCV_MIN_UNKNOWN_SIZE;

  // RF Bridge
  Settings.flag.rf_receive_decimal = RF_DATA_RADIX;
//  for (uint32_t i = 0; i < 17; i++) { Settings.rf_code[i][0] = 0; }
  memcpy_P(Settings.rf_code[0], kDefaultRfCode, 9);

  // Domoticz
  Settings.domoticz_update_timer = DOMOTICZ_UPDATE_TIMER;
//  for (uint32_t i = 0; i < MAX_DOMOTICZ_IDX; i++) {
//    Settings.domoticz_relay_idx[i] = 0;
//    Settings.domoticz_key_idx[i] = 0;
//    Settings.domoticz_switch_idx[i] = 0;
//  }
//  for (uint32_t i = 0; i < MAX_DOMOTICZ_SNS_IDX; i++) {
//    Settings.domoticz_sensor_idx[i] = 0;
//  }

  // Sensor
  Settings.flag.temperature_conversion = TEMP_CONVERSION;
  Settings.flag.pressure_conversion = PRESSURE_CONVERSION;
  Settings.flag2.pressure_resolution = PRESSURE_RESOLUTION;
  Settings.flag2.humidity_resolution = HUMIDITY_RESOLUTION;
  Settings.flag2.temperature_resolution = TEMP_RESOLUTION;
  Settings.flag3.ds18x20_internal_pullup = DS18X20_PULL_UP;
  Settings.flag3.counter_reset_on_tele = COUNTER_RESET;
//  Settings.altitude = 0;

  // Rules
//  Settings.rule_enabled = 0;
//  Settings.rule_once = 0;
//  for (uint32_t i = 1; i < MAX_RULE_SETS; i++) { Settings.rules[i][0] = '\\0'; }
  Settings.flag2.calc_resolution = CALC_RESOLUTION;

  // Timer
  Settings.flag3.timers_enable = TIMERS_ENABLED;

  // Home Assistant
  Settings.flag.hass_light = HASS_AS_LIGHT;
  Settings.flag.hass_discovery = HOME_ASSISTANT_DISCOVERY_ENABLE;
  Settings.flag3.hass_tele_on_power = TELE_ON_POWER;

  // Knx
  Settings.flag.knx_enabled = KNX_ENABLED;
  Settings.flag.knx_enable_enhancement = KNX_ENHANCED;

  // Light
  Settings.flag.pwm_control = LIGHT_MODE;
  Settings.flag.ws_clock_reverse = LIGHT_CLOCK_DIRECTION;
  Settings.flag.light_signal = LIGHT_PAIRS_CO2;
  Settings.flag.not_power_linked = LIGHT_POWER_CONTROL;
  Settings.flag.decimal_text = LIGHT_COLOR_RADIX;
  Settings.flag3.pwm_multi_channels = LIGHT_CHANNEL_MODE;
  Settings.flag3.slider_dimmer_stay_on = LIGHT_SLIDER_POWER;
  Settings.flag4.alexa_ct_range = LIGHT_ALEXA_CT_RANGE;

  Settings.pwm_frequency = PWM_FREQ;
  Settings.pwm_range = PWM_RANGE;
  for (uint32_t i = 0; i < MAX_PWMS; i++) {
    Settings.light_color[i] = DEFAULT_LIGHT_COMPONENT;
//    Settings.pwm_value[i] = 0;
  }
  Settings.light_correction = 1;
  Settings.light_dimmer = DEFAULT_LIGHT_DIMMER;
//  Settings.light_fade = 0;
  Settings.light_speed = 1;
//  Settings.light_scheme = 0;
  Settings.light_width = 1;
//  Settings.light_wakeup = 0;
  Settings.light_pixels = WS2812_LEDS;
//  Settings.light_rotation = 0;
  Settings.ws_width[WS_SECOND] = 1;
  Settings.ws_color[WS_SECOND][WS_RED] = 255;
//  Settings.ws_color[WS_SECOND][WS_GREEN] = 0;
  Settings.ws_color[WS_SECOND][WS_BLUE] = 255;
  Settings.ws_width[WS_MINUTE] = 3;
//  Settings.ws_color[WS_MINUTE][WS_RED] = 0;
  Settings.ws_color[WS_MINUTE][WS_GREEN] = 255;
//  Settings.ws_color[WS_MINUTE][WS_BLUE] = 0;
  Settings.ws_width[WS_HOUR] = 5;
  Settings.ws_color[WS_HOUR][WS_RED] = 255;
//  Settings.ws_color[WS_HOUR][WS_GREEN] = 0;
//  Settings.ws_color[WS_HOUR][WS_BLUE] = 0;

  Settings.dimmer_hw_max = DEFAULT_DIMMER_MAX;
  Settings.dimmer_hw_min = DEFAULT_DIMMER_MIN;

  // Display
//  Settings.display_model = 0;
  Settings.display_mode = 1;
  Settings.display_refresh = 2;
  Settings.display_rows = 2;
  Settings.display_cols[0] = 16;
  Settings.display_cols[1] = 8;
  Settings.display_dimmer = 1;
  Settings.display_size = 1;
  Settings.display_font = 1;
//  Settings.display_rotate = 0;
  Settings.display_address[0] = MTX_ADDRESS1;
  Settings.display_address[1] = MTX_ADDRESS2;
  Settings.display_address[2] = MTX_ADDRESS3;
  Settings.display_address[3] = MTX_ADDRESS4;
  Settings.display_address[4] = MTX_ADDRESS5;
  Settings.display_address[5] = MTX_ADDRESS6;
  Settings.display_address[6] = MTX_ADDRESS7;
  Settings.display_address[7] = MTX_ADDRESS8;

  // Time
  if (((APP_TIMEZONE > -14) && (APP_TIMEZONE < 15)) || (99 == APP_TIMEZONE)) {
    Settings.timezone = APP_TIMEZONE;
    Settings.timezone_minutes = 0;
  } else {
    Settings.timezone = APP_TIMEZONE / 60;
    Settings.timezone_minutes = abs(APP_TIMEZONE % 60);
  }
  SettingsUpdateText(SET_NTPSERVER1, NTP_SERVER1);
  SettingsUpdateText(SET_NTPSERVER2, NTP_SERVER2);
  SettingsUpdateText(SET_NTPSERVER3, NTP_SERVER3);
  for (uint32_t i = 0; i < MAX_NTP_SERVERS; i++) {
    SettingsUpdateText(SET_NTPSERVER1 +i, ReplaceCommaWithDot(SettingsText(SET_NTPSERVER1 +i)));
  }
  Settings.latitude = (int)((double)LATITUDE * 1000000);
  Settings.longitude = (int)((double)LONGITUDE * 1000000);
  SettingsResetStd();
  SettingsResetDst();

  Settings.button_debounce = KEY_DEBOUNCE_TIME;
  Settings.switch_debounce = SWITCH_DEBOUNCE_TIME;

  for (uint32_t j = 0; j < 5; j++) {
    Settings.rgbwwTable[j] = 255;
  }

  Settings.novasds_startingoffset = STARTING_OFFSET;

  SettingsDefaultWebColor();

  memset(&Settings.monitors, 0xFF, 20);  // Enable all possible monitors, displays and sensors
  SettingsEnableAllI2cDrivers();

  // Tuya
  Settings.flag3.tuya_apply_o20 = TUYA_SETOPTION_20;
  Settings.flag3.tuya_serial_mqtt_publish = MQTT_TUYA_RECEIVED;

  Settings.flag3.buzzer_enable = BUZZER_ENABLE;
  Settings.flag3.shutter_mode = SHUTTER_SUPPORT;
  Settings.flag3.pcf8574_ports_inverted = PCF8574_INVERT_PORTS;
  Settings.flag4.zigbee_use_names = ZIGBEE_FRIENDLY_NAMES;
}

/********************************************************************************************/

void SettingsResetStd(void)
{
  Settings.tflag[0].hemis = TIME_STD_HEMISPHERE;
  Settings.tflag[0].week = TIME_STD_WEEK;
  Settings.tflag[0].dow = TIME_STD_DAY;
  Settings.tflag[0].month = TIME_STD_MONTH;
  Settings.tflag[0].hour = TIME_STD_HOUR;
  Settings.toffset[0] = TIME_STD_OFFSET;
}

void SettingsResetDst(void)
{
  Settings.tflag[1].hemis = TIME_DST_HEMISPHERE;
  Settings.tflag[1].week = TIME_DST_WEEK;
  Settings.tflag[1].dow = TIME_DST_DAY;
  Settings.tflag[1].month = TIME_DST_MONTH;
  Settings.tflag[1].hour = TIME_DST_HOUR;
  Settings.toffset[1] = TIME_DST_OFFSET;
}

void SettingsDefaultWebColor(void)
{
  char scolor[10];
  for (uint32_t i = 0; i < COL_LAST; i++) {
    WebHexCode(i, GetTextIndexed(scolor, sizeof(scolor), i, kWebColors));
  }
}

void SettingsEnableAllI2cDrivers(void)
{
  Settings.i2c_drivers[0] = 0xFFFFFFFF;
  Settings.i2c_drivers[1] = 0xFFFFFFFF;
  Settings.i2c_drivers[2] = 0xFFFFFFFF;
}

/********************************************************************************************/

void SettingsDelta(void)
{
  if (Settings.version != VERSION) {      // Fix version dependent changes
    if (Settings.version < 0x06000000) {
      Settings.cfg_size = sizeof(SYSCFG);
      Settings.cfg_crc = GetSettingsCrc();
    }
    if (Settings.version < 0x06000002) {
      for (uint32_t i = 0; i < MAX_SWITCHES; i++) {
        if (i < 4) {
          Settings.switchmode[i] = Settings.interlock[i];
        } else {
          Settings.switchmode[i] = SWITCH_MODE;
        }
      }
      for (uint32_t i = 0; i < sizeof(Settings.my_gp); i++) {
        if (Settings.my_gp.io[i] >= GPIO_SWT5) {  // Move up from GPIO_SWT5 to GPIO_KEY1
          Settings.my_gp.io[i] += 4;
        }
      }
    }
    if (Settings.version < 0x06000003) {
      Settings.flag.mqtt_serial_raw = 0;      // Was rules_enabled until 5.14.0b
      Settings.flag.pressure_conversion = 0;  // Was rules_once until 5.14.0b
      Settings.flag3.data = 0;
    }
    if (Settings.version < 0x06010103) {
      Settings.flag3.timers_enable = 1;
    }
    if (Settings.version < 0x0601010C) {
      Settings.button_debounce = KEY_DEBOUNCE_TIME;
      Settings.switch_debounce = SWITCH_DEBOUNCE_TIME;
    }
    if (Settings.version < 0x0602010A) {
      for (uint32_t j = 0; j < 5; j++) {
        Settings.rgbwwTable[j] = 255;
      }
    }
    if (Settings.version < 0x06030002) {
      Settings.timezone_minutes = 0;
    }
    if (Settings.version < 0x06030004) {
      memset(&Settings.monitors, 0xFF, 20);  // Enable all possible monitors, displays and sensors
    }
    if (Settings.version < 0x0603000E) {
      Settings.flag2.calc_resolution = CALC_RESOLUTION;
    }
    if (Settings.version < 0x0603000F) {
      if (Settings.sleep < 50) {
        Settings.sleep = 50;                // Default to 50 for sleep, for now
      }
    }
    if (Settings.version < 0x06040105) {
      Settings.flag3.mdns_enabled = MDNS_ENABLED;
      Settings.param[P_MDNS_DELAYED_START] = 0;
    }
    if (Settings.version < 0x0604010B) {
      Settings.interlock[0] = 0xFF;         // Legacy support using all relays in one interlock group
      for (uint32_t i = 1; i < MAX_INTERLOCKS; i++) { Settings.interlock[i] = 0; }
    }
    if (Settings.version < 0x0604010D) {
      Settings.param[P_BOOT_LOOP_OFFSET] = BOOT_LOOP_OFFSET;  // SetOption36
    }
    if (Settings.version < 0x06040110) {
      ModuleDefault(WEMOS);
    }
    if (Settings.version < 0x06040113) {
      Settings.param[P_RGB_REMAP] = RGB_REMAP_RGBW;
    }
    if (Settings.version < 0x06050003) {
      Settings.novasds_startingoffset = STARTING_OFFSET;
    }
    if (Settings.version < 0x06050006) {
      SettingsDefaultWebColor();
    }
    if (Settings.version < 0x06050007) {
      Settings.ledmask = APP_LEDMASK;
    }
    if (Settings.version < 0x0605000A) {
      Settings.my_adc0 = ADC0_NONE;
    }
    if (Settings.version < 0x0605000D) {
      Settings.param[P_IR_UNKNOW_THRESHOLD] = IR_RCV_MIN_UNKNOWN_SIZE;
    }
    if (Settings.version < 0x06060001) {
      Settings.param[P_OVER_TEMP] = ENERGY_OVERTEMP;
    }
    if (Settings.version < 0x06060007) {
      memset((char*)&Settings +0xE00, 0x00, sizeof(SYSCFG) -0xE00);
    }
    if (Settings.version < 0x06060008) {
      // Move current tuya dimmer range to the new param.
      if (Settings.flag3.tuya_serial_mqtt_publish) { // ex Settings.flag3.ex_tuya_dimmer_range_255 SetOption
        Settings.param[P_ex_DIMMER_MAX] = 100;
      } else {
        Settings.param[P_ex_DIMMER_MAX] = 255;
      }
    }
    if (Settings.version < 0x06060009) {
      Settings.baudrate = APP_BAUDRATE / 300;
      Settings.sbaudrate = SOFT_BAUDRATE / 300;
    }
    if (Settings.version < 0x0606000A) {
      uint8_t tuyaindex = 0;
      if (Settings.param[P_BACKLOG_DELAY] > 0) {             // ex SetOption34
        Settings.tuya_fnid_map[tuyaindex].fnid = 21;         // TUYA_MCU_FUNC_DIMMER - Move Tuya Dimmer Id to Map
        Settings.tuya_fnid_map[tuyaindex].dpid = Settings.param[P_BACKLOG_DELAY];
        tuyaindex++;
      } else if (Settings.flag3.fast_power_cycle_disable == 1) {  // ex SetOption65
        Settings.tuya_fnid_map[tuyaindex].fnid = 11;         // TUYA_MCU_FUNC_REL1 - Create FnID for Switches
        Settings.tuya_fnid_map[tuyaindex].dpid = 1;
        tuyaindex++;
      }
      if (Settings.param[P_ex_TUYA_RELAYS] > 0) {
        for (uint8_t i = 0 ; i < Settings.param[P_ex_TUYA_RELAYS]; i++) {  // ex SetOption41
          Settings.tuya_fnid_map[tuyaindex].fnid = 12 + i;   // TUYA_MCU_FUNC_REL2 -  Create FnID for Switches
          Settings.tuya_fnid_map[tuyaindex].dpid = i + 2;
          tuyaindex++;
        }
      }
      if (Settings.param[P_ex_TUYA_POWER_ID] > 0) {          // ex SetOption46
        Settings.tuya_fnid_map[tuyaindex].fnid = 31;         // TUYA_MCU_FUNC_POWER -  Move Tuya Power Id to Map
        Settings.tuya_fnid_map[tuyaindex].dpid = Settings.param[P_ex_TUYA_POWER_ID];
        tuyaindex++;
      }
      if (Settings.param[P_ex_TUYA_VOLTAGE_ID] > 0) {        // ex SetOption44
        Settings.tuya_fnid_map[tuyaindex].fnid = 33;         // TUYA_MCU_FUNC_VOLTAGE - Move Tuya Voltage Id to Map
        Settings.tuya_fnid_map[tuyaindex].dpid = Settings.param[P_ex_TUYA_VOLTAGE_ID];
        tuyaindex++;
      }
      if (Settings.param[P_ex_TUYA_CURRENT_ID] > 0) {        // ex SetOption45
        Settings.tuya_fnid_map[tuyaindex].fnid = 32;         // TUYA_MCU_FUNC_CURRENT - Move Tuya Current Id to Map
        Settings.tuya_fnid_map[tuyaindex].dpid = Settings.param[P_ex_TUYA_CURRENT_ID];
      }
    }
    if (Settings.version < 0x0606000C) {
      memset((char*)&Settings +0x1D6, 0x00, 16);
    }
    if (Settings.version < 0x0606000F) {
      Settings.ex_shutter_accuracy = 0;
      Settings.ex_mqttlog_level = MQTT_LOG_LEVEL;
    }
    if (Settings.version < 0x06060011) {
      Settings.param[P_BACKLOG_DELAY] = MIN_BACKLOG_DELAY;
    }
    if (Settings.version < 0x06060012) {
      Settings.dimmer_hw_min = DEFAULT_DIMMER_MIN;
      Settings.dimmer_hw_max = DEFAULT_DIMMER_MAX;
      if (TUYA_DIMMER == Settings.module) {
        if (Settings.flag3.ex_tuya_dimmer_min_limit) {
          Settings.dimmer_hw_min = 25;
        } else {
          Settings.dimmer_hw_min = 1;
        }
        Settings.dimmer_hw_max = Settings.param[P_ex_DIMMER_MAX];
      }
      else if (PS_16_DZ == Settings.module) {
        Settings.dimmer_hw_min = 10;
        Settings.dimmer_hw_max = Settings.param[P_ex_DIMMER_MAX];
      }
    }
    if (Settings.version < 0x06060014) {
      // Clear unused parameters for future use
/*
      Settings.flag3.tuya_serial_mqtt_publish = 0;  // ex Settings.flag3.ex_tuya_dimmer_range_255
      Settings.flag3.ex_tuya_dimmer_min_limit = 0;
      Settings.param[P_ex_TUYA_RELAYS] = 0;
      Settings.param[P_ex_DIMMER_MAX] = 0;
      Settings.param[P_ex_TUYA_VOLTAGE_ID] = 0;
      Settings.param[P_ex_TUYA_CURRENT_ID] = 0;
      Settings.param[P_ex_TUYA_POWER_ID] = 0;
      Settings.ex_baudrate = 0;
      Settings.ex_sbaudrate = 0;
*/
      Settings.flag3.fast_power_cycle_disable = 0;
      Settings.energy_power_delta = Settings.ex_energy_power_delta;
      Settings.ex_energy_power_delta = 0;
    }
    if (Settings.version < 0x06060015) {
      if ((EX_WIFI_SMARTCONFIG == Settings.ex_sta_config) || (EX_WIFI_WPSCONFIG == Settings.ex_sta_config)) {
        Settings.ex_sta_config = WIFI_MANAGER;
      }
    }

    if (Settings.version < 0x07000002) {
      Settings.web_color2[0][0] = Settings.web_color[0][0];
      Settings.web_color2[0][1] = Settings.web_color[0][1];
      Settings.web_color2[0][2] = Settings.web_color[0][2];
    }
    if (Settings.version < 0x07000003) {
      SettingsEnableAllI2cDrivers();
    }
    if (Settings.version < 0x07000004) {
      Settings.ex_wifi_output_power = 170;
    }
    if (Settings.version < 0x07010202) {
      Settings.ex_serial_config = TS_SERIAL_8N1;
    }
    if (Settings.version < 0x07010204) {
      if (Settings.flag3.ex_cors_enabled == 1) {
        strlcpy(Settings.ex_cors_domain, CORS_ENABLED_ALL, sizeof(Settings.ex_cors_domain));
      } else {
        Settings.ex_cors_domain[0] = 0;
      }
    }
    if (Settings.version < 0x07010205) {
      Settings.seriallog_level = Settings.ex_seriallog_level;  // 09E -> 452
      Settings.sta_config = Settings.ex_sta_config;            // 09F -> EC7
      Settings.sta_active = Settings.ex_sta_active;            // 0A0 -> EC8
      memcpy((char*)&Settings.rule_stop, (char*)&Settings.ex_rule_stop, 47);  // 1A7 -> EC9
    }
    if (Settings.version < 0x07010206) {
      Settings.flag4 = Settings.ex_flag4;                      // 1E0 -> EF8
      Settings.mqtt_port = Settings.ex_mqtt_port;              // 20A -> EFC
      memcpy((char*)&Settings.serial_config, (char*)&Settings.ex_serial_config, 5);  // 1E4 -> EFE
    }

    if (Settings.version < 0x08000000) {
      char temp[strlen(Settings.text_pool) +1];           strncpy(temp, Settings.text_pool, sizeof(temp));  // Was ota_url
      char temp21[strlen(Settings.ex_mqtt_prefix[0]) +1]; strncpy(temp21, Settings.ex_mqtt_prefix[0], sizeof(temp21));
      char temp22[strlen(Settings.ex_mqtt_prefix[1]) +1]; strncpy(temp22, Settings.ex_mqtt_prefix[1], sizeof(temp22));
      char temp23[strlen(Settings.ex_mqtt_prefix[2]) +1]; strncpy(temp23, Settings.ex_mqtt_prefix[2], sizeof(temp23));
      char temp31[strlen(Settings.ex_sta_ssid[0]) +1];    strncpy(temp31, Settings.ex_sta_ssid[0], sizeof(temp31));
      char temp32[strlen(Settings.ex_sta_ssid[1]) +1];    strncpy(temp32, Settings.ex_sta_ssid[1], sizeof(temp32));
      char temp41[strlen(Settings.ex_sta_pwd[0]) +1];     strncpy(temp41, Settings.ex_sta_pwd[0], sizeof(temp41));
      char temp42[strlen(Settings.ex_sta_pwd[1]) +1];     strncpy(temp42, Settings.ex_sta_pwd[1], sizeof(temp42));
      char temp5[strlen(Settings.ex_hostname) +1];        strncpy(temp5, Settings.ex_hostname, sizeof(temp5));
      char temp6[strlen(Settings.ex_syslog_host) +1];     strncpy(temp6, Settings.ex_syslog_host, sizeof(temp6));
      char temp7[strlen(Settings.ex_mqtt_host) +1];       strncpy(temp7, Settings.ex_mqtt_host, sizeof(temp7));
      char temp8[strlen(Settings.ex_mqtt_client) +1];     strncpy(temp8, Settings.ex_mqtt_client, sizeof(temp8));
      char temp9[strlen(Settings.ex_mqtt_user) +1];       strncpy(temp9, Settings.ex_mqtt_user, sizeof(temp9));
      char temp10[strlen(Settings.ex_mqtt_pwd) +1];       strncpy(temp10, Settings.ex_mqtt_pwd, sizeof(temp10));
      char temp11[strlen(Settings.ex_mqtt_topic) +1];     strncpy(temp11, Settings.ex_mqtt_topic, sizeof(temp11));
      char temp12[strlen(Settings.ex_button_topic) +1];   strncpy(temp12, Settings.ex_button_topic, sizeof(temp12));
      char temp13[strlen(Settings.ex_mqtt_grptopic) +1];  strncpy(temp13, Settings.ex_mqtt_grptopic, sizeof(temp13));

      memset(Settings.text_pool, 0x00, settings_text_size);
      SettingsUpdateText(SET_OTAURL, temp);
      SettingsUpdateText(SET_MQTTPREFIX1, temp21);
      SettingsUpdateText(SET_MQTTPREFIX2, temp22);
      SettingsUpdateText(SET_MQTTPREFIX3, temp23);
      SettingsUpdateText(SET_STASSID1, temp31);
      SettingsUpdateText(SET_STASSID2, temp32);
      SettingsUpdateText(SET_STAPWD1, temp41);
      SettingsUpdateText(SET_STAPWD2, temp42);
      SettingsUpdateText(SET_HOSTNAME, temp5);
      SettingsUpdateText(SET_SYSLOG_HOST, temp6);
#if defined(USE_MQTT_TLS) && defined(USE_MQTT_AWS_IOT)
      if (!strlen(Settings.ex_mqtt_user)) {
        SettingsUpdateText(SET_MQTT_HOST, temp7);
        SettingsUpdateText(SET_MQTT_USER, temp9);
      } else {
        char aws_mqtt_host[66];
        snprintf_P(aws_mqtt_host, sizeof(aws_mqtt_host), PSTR(""%s%s""), temp9, temp7);
        SettingsUpdateText(SET_MQTT_HOST, aws_mqtt_host);
        SettingsUpdateText(SET_MQTT_USER, """");
      }
#else
      SettingsUpdateText(SET_MQTT_HOST, temp7);
      SettingsUpdateText(SET_MQTT_USER, temp9);
#endif
      SettingsUpdateText(SET_MQTT_CLIENT, temp8);
      SettingsUpdateText(SET_MQTT_PWD, temp10);
      SettingsUpdateText(SET_MQTT_TOPIC, temp11);
      SettingsUpdateText(SET_MQTT_BUTTON_TOPIC, temp12);
      SettingsUpdateText(SET_MQTT_GRP_TOPIC, temp13);

      SettingsUpdateText(SET_WEBPWD, Settings.ex_web_password);
      SettingsUpdateText(SET_CORS, Settings.ex_cors_domain);
      SettingsUpdateText(SET_MQTT_FULLTOPIC, Settings.ex_mqtt_fulltopic);
      SettingsUpdateText(SET_MQTT_SWITCH_TOPIC, Settings.ex_switch_topic);
      SettingsUpdateText(SET_STATE_TXT1, Settings.ex_state_text[0]);
      SettingsUpdateText(SET_STATE_TXT2, Settings.ex_state_text[1]);
      SettingsUpdateText(SET_STATE_TXT3, Settings.ex_state_text[2]);
      SettingsUpdateText(SET_STATE_TXT4, Settings.ex_state_text[3]);
      SettingsUpdateText(SET_NTPSERVER1, Settings.ex_ntp_server[0]);
      SettingsUpdateText(SET_NTPSERVER2, Settings.ex_ntp_server[1]);
      SettingsUpdateText(SET_NTPSERVER3, Settings.ex_ntp_server[2]);
      SettingsUpdateText(SET_MEM1, Settings.script_pram[0]);
      SettingsUpdateText(SET_MEM2, Settings.script_pram[1]);
      SettingsUpdateText(SET_MEM3, Settings.script_pram[2]);
      SettingsUpdateText(SET_MEM4, Settings.script_pram[3]);
      SettingsUpdateText(SET_MEM5, Settings.script_pram[4]);
      SettingsUpdateText(SET_FRIENDLYNAME1, Settings.ex_friendlyname[0]);
      SettingsUpdateText(SET_FRIENDLYNAME2, Settings.ex_friendlyname[1]);
      SettingsUpdateText(SET_FRIENDLYNAME3, Settings.ex_friendlyname[2]);
      SettingsUpdateText(SET_FRIENDLYNAME4, Settings.ex_friendlyname[3]);
    }

    Settings.version = VERSION;
    SettingsSave(1);
  }
}
",16284,True,2772.965422651241,median
"package away3d.core.math
{
	public class PoissonLookup
	{
		private static var _distributions : Vector.<Vector.<Number>>;

		public static function initDistributions() : void
		{
			// precalculated for best control
			_distributions = new Vector.<Vector.<Number>>();
			_distributions[0] = new <Number>[0.3082841, 0.4320919, 0, 0];
			_distributions[1] = new <Number>[0.3082841, 0.4320919, -0.2274942, -0.6640266];
			_distributions[2] = new <Number>[0.8742689, 0.0009265686, -0.6864116, -0.5536607, -0.2325206, 0.7678371, 0, 0 ];
			_distributions[3] = new <Number>[0.3913446, -0.7084417, -0.7511101, -0.5935929, -0.2323436, 0.5320091, 0.8435315, 0.5035911 ];
			_distributions[4] = new <Number>[0.2122471, -0.5771395, -0.8543506, -0.1763534, 0.5189021, 0.8323698, -0.3616908, 0.5865368, 0.9523004, -0.04948437, 0, 0];
			_distributions[5] = new <Number>[0.5791035, 0.3496495, 0.2959551, -0.6006749, -0.2419119, -0.06879545, -0.7403072, 0.6110353, -0.04555973, 0.8059174, -0.5275017, -0.737129];
			_distributions[6] = new <Number>[0.06941478, 0.8519508, -0.7441907, 0.2426432, 0.6439992, -0.2405252, -0.1007523, -0.2327587, -0.6427067, -0.7248485, 0.8050759, 0.5492936, 0.3573822, -0.8824506, 0, 0];
			_distributions[7] = new <Number>[0.8509863, 0.4452587, -0.09507271, 0.2073005, 0.1706571, -0.6434793, 0.8029777, -0.2718274, -0.4401725, 0.8196304, 0.2715359, 0.8598521, -0.8121575, -0.006447683, -0.6486837, -0.7237598];
			_distributions[8] = new <Number>[0.6951686, -0.2680728, -0.04933243, 0.3710589, 0.6592212, 0.3661054, -0.01579228, -0.6909603, -0.3275101, -0.1756866, 0.3811549, 0.9218544, -0.216032, 0.9755028, -0.7065172, 0.3355389, -0.6579109, -0.6798355, 0, 0];
			_distributions[9] = new <Number>[0.6181276, -0.09790418, -0.2537868, -0.5570995, -0.1964931, 0.3459414, 0.3474613, -0.8885581, 0.5135743, 0.5753114, -0.9549091, 0.1480672, -0.8711916, -0.4293123, -0.6928071, 0.6190156, -0.13369, 0.8892705, 0.0548224, -0.1246777];
			_distributions[10] = new <Number>[0.4853027, -0.5080479, -0.1331675, -0.506597, 0.139575, 0.01316885, 0.803486, -0.07568797, 0.5240274, 0.4883182, -0.4334005, 0.1207938, -0.7794577, -0.3985141, 0.1576432, -0.9861221, -0.3712867, 0.6959021, 0.1517378, 0.9847429, -0.9762396, 0.1661073, 0, 0];
			_distributions[11] = new <Number>[-0.2790166, -0.01252619, 0.3389016, 0.3921154, 0.2408341, -0.313211, -0.8151779, -0.3898362, -0.6347761, 0.3486495, 0.09471484, -0.7722448, -0.1385674, 0.6364574, 0.2456331, 0.9295807, -0.3864306, -0.8247881, 0.6111673, -0.7164014, 0.8287669, 0.05466961, 0.837706, 0.5415626];
			_distributions[12] = new <Number>[0.056417, 0.3185693, -0.8245888, 0.1882799, 0.8575996, 0.1136829, 0.1070375, 0.875332, 0.4076743, -0.06000621, -0.4311306, 0.7239349, 0.2677574, -0.538472, -0.08486642, -0.2083647, -0.888989, -0.3906443, -0.4768958, -0.6664082, 0.09334993, -0.9861541, 0.808736, -0.455949, 0.5889823, 0.7660807, 0, 0];
			_distributions[13] = new <Number>[-0.2681346, -0.3955857, -0.1315102, -0.8852947, -0.5143692, 0.09551838, 0.4344836, -0.546945, -0.8620899, -0.3813288, 0.1650431, 0.02034803, -0.1543657, 0.3842218, -0.828457, 0.5376903, -0.6145, -0.7818927, -0.2639062, 0.8784655, 0.1912684, 0.9720125, 0.3135219, 0.5224229, 0.7850655, 0.4592297, 0.7465045, -0.1368916];
			_distributions[14] = new <Number>[0.4241029, 0.695281, 0.150511, -0.02304107, -0.2482675, 0.9120338, 0.8057325, 0.2622084, -0.2445909, 0.2765962, 0.8588713, -0.1772072, 0.3117845, -0.4385471, -0.3923851, -0.3298936, -0.1751254, -0.7405846, 0.6926506, -0.684163, -0.9304563, -0.3254691, -0.8533293, 0.1523024, 0.2510415, -0.917345, -0.6239773, -0.7105472, -0.6104624, 0.6041355, 0, 0];
			_distributions[15] = new <Number>[0.5844554, 0.06651045, 0.1343258, 0.6756578, 0.3799674, -0.6301104, 0.5590436, 0.7940555, 0.09574714, 0.02262517, 0.8697868, 0.393301, 0.003945862, -0.421735, 0.9043913, -0.2432393, -0.4844007, 0.7190998, -0.3201078, 0.2972371, -0.3852352, -0.6341155, -0.5413069, -0.09223081, -0.8468984, -0.5126905, 0.004156174, -0.8633173, -0.9681889, -0.03305046, -0.846509, 0.4414353];
			_distributions[16] = new <Number>[0.4506488, 0.657668, 0.4621297, 0.07441051, -0.2782125, 0.6201044, 0.9750003, 0.09110117, 0.1019436, 0.2986514, 0.03457398, 0.9631706, 0.542098, -0.5505635, 0.8675668, 0.4938077, -0.5414361, 0.2655292, -0.7941836, 0.6003053, -0.09847672, -0.1001604, -0.9316511, -0.08572888, 0.07286467, -0.611899, -0.5232627, -0.4082253, -0.5481608, -0.827938, -0.1551939, -0.9621193, 0.9220031, -0.3315949, 0, 0];
			_distributions[17] = new <Number>[0.197908, -0.4697656, -0.4474689, -0.3428435, 0.8529873, -0.2228634, 0.6022478, -0.5469642, 0.2545276, -0.931133, -0.1507547, -0.7855865, -0.07606658, 0.1011628, 0.3046715, 0.2785755, 0.4698432, -0.1064076, 0.6831254, 0.4152522, 0.1374381, 0.8363233, -0.2166121, 0.6682042, 0.5511393, 0.7996449, -0.4278994, 0.28836, -0.8875198, 0.2181732, -0.8772842, -0.2818254, -0.7000262, 0.5762185, -0.6062385, -0.7439126];
			_distributions[18] = new <Number>[0.6645703, -0.05678739, 0.5720971, 0.4533803, -0.07660709, 0.08802763, 0.5163431, -0.4426552, 0.1163455, -0.3404382, -0.4004807, -0.5046007, 0.2932099, -0.8201418, -0.5322125, 0.03834766, -0.1490209, -0.8817304, -0.8000439, -0.3509448, 0.5260983, 0.8421043, 0.1197811, 0.6963812, 0.9498612, 0.3122156, -0.9285746, 0.02120355, -0.6670724, 0.7217396, 0.9155889, -0.3510147, -0.271941, 0.4727852, 0.318879, 0.1634057, -0.2686755, 0.9253026, 0, 0];
			_distributions[19] = new <Number>[0.5064292, 0.422527, 0.8935515, -0.06610427, 0.1199719, 0.175568, 0.403388, -0.2003276, 0.1657927, 0.8154403, 0.9301245, 0.2929218, -0.1644068, 0.6201534, 0.7113559, -0.6589743, -0.3364046, -0.1799502, 0.02109996, -0.392765, -0.382213, 0.3219992, -0.9201946, 0.1207967, -0.726185, 0.4291916, -0.7443482, -0.2480059, -0.5147594, 0.7418784, 0.1935272, -0.7406143, -0.3643523, -0.5559214, -0.7147766, -0.6326278, -0.2524151, -0.9096627, 0.5161405, 0.7908453];
			_distributions[20] = new <Number>[0.7921003, -0.3032096, 0.5992879, -0.009052323, 0.2538549, -0.1872749, 0.7053444, 0.3677175, 0.5417761, -0.8170255, 0.9749611, 0.1210478, 0.1969143, -0.6117041, -0.1824499, -0.4634196, -0.1181338, -0.8668742, -0.3050112, -0.1352596, -0.4409327, -0.7082354, -0.03225285, 0.1171548, 0.3113096, 0.3250439, -0.8166144, -0.463995, -0.01014475, 0.4715334, -0.6868284, 0.05091889, -0.4011163, 0.2717285, -0.06756835, 0.8307694, -0.7938535, 0.4352129, -0.4663842, 0.7165329, 0.559729, 0.8093995, 0, 0];
			_distributions[21] = new <Number>[0.07832243, 0.426151, -0.3856795, 0.5799953, 0.01970797, 0.06706189, 0.4822682, 0.3014512, -0.1532982, 0.87485, -0.4959527, 0.07888043, 0.260601, -0.2304784, 0.4996209, 0.7167382, 0.585986, -0.04265174, -0.7679967, 0.5509416, -0.9041753, 0.1802134, -0.8407655, -0.4442826, -0.2058258, -0.2636995, -0.4984115, -0.5928579, 0.2926032, -0.7886473, -0.06933882, -0.621177, 0.578115, -0.4813387, 0.8981777, -0.3291056, 0.1942733, 0.9255584, 0.8084362, 0.5066984, 0.9920095, 0.03103104, -0.2403206, -0.9389018];
			_distributions[22] = new <Number>[-0.5691095, 0.1014316, -0.7788262, 0.384012, -0.8253665, -0.1645582, -0.1830993, 0.002997211, -0.2555013, -0.4177977, -0.6640869, -0.4794711, -0.2351242, 0.5850121, 0.02436554, 0.2825883, 0.006061143, -0.8200245, 0.1618791, -0.3063331, -0.3765897, -0.7249815, 0.6092919, -0.6769328, -0.5956934, 0.6957655, 0.5383642, 0.4522677, -0.1489165, 0.9125596, 0.4167473, 0.1335986, 0.1898309, 0.5874342, 0.2288171, 0.9624356, 0.7540846, -0.07672304, 0.8986252, 0.2788797, 0.3555991, -0.9262139, 0.8454325, -0.4027667, 0.4945236, -0.2935512, 0, 0];
			_distributions[23] = new <Number>[-0.4481403, -0.3758374, -0.8877251, 0.08739938, 0.05015831, -0.1339983, -0.4070427, -0.8534173, 0.1019274, -0.5503222, -0.445998, 0.1997541, -0.8686263, -0.2788867, -0.7695944, -0.6033704, -0.05515742, -0.885711, -0.7714347, 0.5790485, 0.3466263, -0.8799297, 0.4487582, -0.5321087, -0.2461368, 0.6053771, -0.05568117, 0.2457351, -0.4668669, 0.8523816, 0.8103387, -0.4255538, 0.4054182, -0.175663, -0.2802011, -0.08920153, 0.2665959, 0.382935, 0.555679, 0.1621837, 0.105246, 0.8420411, 0.6921161, 0.6902903, 0.880946, 0.2483067, 0.9699264, -0.1021767];
			_distributions[24] = new <Number>[-0.1703323, -0.3119385, 0.2916039, -0.2988263, -0.008472982, -0.9277695, -0.7730271, -0.3277904, 0.3440474, -0.6815342, -0.2910278, 0.03461745, -0.6764899, -0.657078, -0.3505501, -0.7311988, -0.03478927, 0.3258755, -0.6048835, 0.159423, 0.2035525, 0.02212214, 0.5116573, 0.2226856, 0.6664805, -0.2500189, 0.7147882, -0.6609634, 0.03030632, -0.5763278, -0.2516585, 0.6116219, -0.9434413, -0.0116792, 0.9061816, 0.2491155, 0.182867, 0.6076167, 0.286593, 0.9485695, -0.5992439, 0.6970096, -0.2082874, 0.9416641, 0.9880044, -0.1541709, -0.9122881, 0.331555, 0.7324886, 0.6725098, 0, 0];
			_distributions[25] = new <Number>[0.3869598, -0.04974834, 0.7168844, -0.0693711, -0.07166742, 0.1725325, 0.4599592, 0.3232779, 0.5872094, -0.4198674, 0.2442266, -0.625667, 0.1254557, 0.4500048, -0.2290154, -0.1803567, 0.890583, 0.3373493, 0.1256081, 0.7853789, -0.2676466, 0.5305805, -0.7063224, 0.252168, -0.3989835, 0.1189921, 0.09617215, -0.2451447, 0.6302541, 0.6085876, 0.9380925, -0.3234899, 0.5086241, -0.8573482, 0.03576187, -0.9876697, -0.0876712, -0.6365195, -0.5276513, 0.823456, -0.6935764, -0.2240411, -0.5212318, -0.5383121, -0.2116208, 0.9639363, -0.9840096, 0.02743555, -0.3991577, -0.8994547, -0.7830126, 0.614068];
			_distributions[26] = new <Number>[-0.8366601, 0.4464895, -0.5917366, -0.02073906, -0.9845258, 0.1635625, -0.3097973, 0.4379579, -0.5478154, 0.7173221, -0.1685888, 0.9261969, 0.01503595, 0.6046097, 0.4452421, 0.5449086, 0.0315687, 0.1944619, 0.3753404, 0.8688548, 0.4143643, 0.1396648, 0.8711032, 0.4304703, 0.7328773, 0.1461501, 0.6374492, -0.3521495, 0.145613, -0.1341466, 0.9040975, -0.135123, -0.7839059, -0.5450199, -0.516019, -0.3320859, -0.206158, -0.4431106, -0.9703014, -0.2368356, -0.2473119, -0.0864351, 0.2130725, -0.4604077, -0.003726701, -0.7122303, -0.4072131, -0.6833169, 0.1632999, -0.9776646, 0.4686888, -0.680495, -0.2293511, -0.9509777, 0, 0];
			_distributions[27] = new <Number>[0.107311, -0.1311369, -0.4194764, -0.3148777, 0.6171439, -0.2745973, 0.2796618, 0.1937153, -0.09106886, 0.4180236, 0.6044006, 0.05577846, 0.02927299, -0.6738263, -0.2580845, 0.1179939, -0.09023564, -0.3830024, 0.3570953, -0.5000587, 0.81591, -0.5518309, 0.9300217, -0.1257987, 0.4904627, -0.8381903, -0.3163182, -0.8632009, 0.1137595, -0.9875998, 0.8390043, 0.3538185, 0.2149114, 0.4993694, 0.5191584, 0.3833552, 0.5002763, 0.7061465, -0.2567276, 0.9068756, -0.5197366, 0.3467845, 0.03668867, 0.9734009, -0.5347553, 0.66747, -0.9028882, 0.1023768, -0.8967977, 0.412834, -0.5821944, 0.0426479, -0.8032165, -0.2397038, -0.5597343, -0.6358021];
			_distributions[28] = new <Number>[-0.6562496, -0.1781036, -0.9301494, 0.1185208, -0.3861143, -0.4153562, -0.1560799, -0.1099607, -0.5587025, 0.395218, -0.5322112, -0.699701, -0.5008639, 0.08726846, -0.970524, -0.1963461, -0.813577, -0.5185111, -0.1644458, 0.298, -0.3216791, 0.639982, 0.3315373, 0.3339162, 0.2383235, -0.00105722, 0.1137828, 0.5450742, -0.01899921, 0.8798413, 0.2849685, 0.8255596, 0.6974412, 0.2123175, 0.7588523, 0.5470437, 0.5102502, -0.1687844, 0.5853448, 0.8033476, 0.2590716, -0.5262504, 0.5607718, -0.6342825, 0.8666443, -0.1491841, 0.8341052, -0.4935003, -0.1568441, -0.6634066, 0.2512113, -0.8769391, -0.2559827, -0.9572457, -0.01928852, -0.3966542, -0.750667, 0.6409678, 0, 0];
			_distributions[29] = new <Number>[0.3454786, -0.04837726, 0.2649553, 0.2406852, 0.5599093, -0.3839145, -0.1111814, -0.05502108, 0.7586042, -0.05818377, 0.2519488, -0.4665135, -0.1264972, 0.2602723, -0.08766216, -0.3671907, 0.6428129, 0.3999204, -0.6105871, -0.1246869, -0.4589451, -0.7646643, -0.03021116, -0.7899352, -0.6036922, -0.4293956, -0.2481938, 0.6534185, 0.102798, 0.6784465, -0.6392644, 0.4821358, -0.6789002, 0.1779133, -0.9140783, -0.1989647, -0.9262617, 0.3381507, 0.4794891, -0.8093274, 0.3959447, 0.668478, 0.9602883, 0.2272305, -0.123672, 0.9210883, 0.2375148, 0.9523395, -0.52898, 0.7973378, -0.382433, 0.1228794, 0.695015, 0.6948439, 0.7530277, -0.6458191, 0.8777987, -0.3272956, 0.2318525, -0.962768];
			_distributions[30] = new <Number>[0.4518921, -0.1146195, 0.4720805, -0.4238748, 0.3655423, 0.1806341, 0.1589939, -0.23568, 0.7673324, -0.5149941, 0.01163658, 0.09045836, 0.7010971, 0.1245747, 0.7518286, -0.1855433, 0.4960719, 0.4601022, 0.2566979, -0.6308268, -0.0654714, -0.5126389, -0.1823319, -0.1343282, -0.1464312, 0.4883236, -0.3858738, 0.203523, 0.1484799, 0.4432284, -0.477109, -0.116241, 0.2719092, 0.7208626, 0.9104174, 0.3578536, -0.5956199, 0.7662588, -0.6996251, 0.3678654, -0.2514512, 0.9251933, 0.1275825, -0.9478135, -0.204608, -0.8611552, 0.4264838, -0.877443, 0.9854161, 0.05521112, 0.5912951, 0.7997434, 0.1140349, 0.982093, -0.9324368, -0.2094094, -0.42436, -0.6441524, -0.6722705, -0.3554261, -0.7844236, 0.08587621, 0, 0];
			_distributions[31] = new <Number>[-0.4206714, -0.5613642, -0.8733016, -0.3373051, -0.1046226, -0.2902999, -0.1318562, -0.8434365, 0.1145093, -0.5962623, -0.4965627, -0.1873259, -0.5011808, -0.8546229, -0.7165636, -0.5743566, 0.1090901, 0.2017643, 0.3404809, -0.220455, -0.1989015, 0.2372122, -0.4538706, 0.0979171, 0.4514146, -0.572846, 0.2314168, -0.8514503, -0.4247236, 0.5650803, -0.943347, 0.04514639, -0.1309718, 0.5221877, -0.7004157, 0.4561877, 0.6306441, 0.04448673, 0.4301621, 0.5766876, 0.1078042, 0.7245752, 0.3875354, 0.2794483, 0.702876, -0.2924213, 0.7360667, -0.6210318, 0.7486517, 0.6531103, 0.4898235, 0.8591025, 0.6549174, 0.3854057, -0.2596106, 0.7916998, 0.9251194, -0.05296265, -0.5620695, 0.820877, -0.01228026, 0.9937211, 0.9612103, 0.2628758];
		}

		public static function getDistribution(n : int) : Vector.<Number>
		{
			if (!_distributions) initDistributions();
			if (n < 2 || n > 32) return null;
			return _distributions[n-1];
		}
	}
}
",12218,True,4243.823161306494,median
"#include ""cmd.h""

// command line message buffer and pointer
static uint8_t msg[MAX_MSG_SIZE] = """";
static uint8_t *msg_ptr = msg;

int echo_on = 1;
int errorlevel = 0;

// Exec script stack, this allows executing scripts from within scripts.
typedef struct script_s {
  char m_filename[MAX_FILE_PATH+1];
  FsFile m_file;
  int m_line;
} script_t;

#define MAX_SCRIPTLEVEL 8
script_t scriptstack[MAX_SCRIPTLEVEL];
int scriptlevel = -1;

#define exec_filename scriptstack[scriptlevel].m_filename
#define exec_line scriptstack[scriptlevel].m_line

char cmd_prefix[256] = ""/"";

extern uint8_t mbr_bin[];

void cmdDisplay() {
  if(cmd_prefix[0] != 0) {
    Serial.printf(""[%s] $ "", cmd_prefix);
  } else {
    strcpy(cmd_prefix, ""/"");
    Serial.print(""[/] $ "");
  }
}

/*
 * Like strtok, but with quotes
 */
char *strmbtok ( char *input, const char *delimit, const char *openblock, const char *closeblock) {
    static char *token = NULL;
    char *lead = NULL;
    char *block = NULL;
    int iBlock = 0;
    int iBlockIndex = 0;

    if ( input != NULL) {
        token = input;
        lead = input;
    }
    else {
        lead = token;
        if ( *token == '\\0') {
            lead = NULL;
        }
    }

    while ( *token != '\\0') {
        // We are in a quote, is this a matching close quote character?
        if ( iBlock) {
            if ( closeblock[iBlockIndex] == *token) {
                iBlock = 0;
            }
            token++;
            continue;
        }

        // Is this a valid opening quote?
        if ( ( block = strchr ( openblock, *token)) != NULL) {
            iBlock = 1;
            iBlockIndex = block - openblock;
            token++;
            continue;
        }
        if ( strchr ( delimit, *token) != NULL) {
            *token = '\\0';
            token++;
            break;
        }
        token++;
    }
    return lead;
}

/*
 * Remove quotes from quoted strings.
 */
void unquote(char *out, char *in) {
  char tmp_str[256];

  if(!in) return;
  if(!out) return;

  char *pout = tmp_str;
  char inQuote = 0;
  while(*in != 0) {
    if(inQuote && (*in == inQuote)) {
      inQuote = 0;
    } else if(!inQuote && (*in == '""')) {
      inQuote = '""';
    } else if(!inQuote && (*in == '\\'')) {
      inQuote = '\\'';
    } else {
      *pout = *in;
      pout++;
    }
    in++;
  }
  *pout = 0;

  // This way you can have out == in
  strcpy(out, tmp_str);
}

#define ENVIRONMENT_SIZE 32
#define ENVIRONMENT_KEY_SIZE 32
#define ENVIRONMENT_VALUE_SIZE (MAX_FILE_PATH+1)

typedef struct cmdvar_s {
  char key[ENVIRONMENT_KEY_SIZE];
  char value[ENVIRONMENT_VALUE_SIZE];
} cmdvar_t;

cmdvar_t cmdenv[ENVIRONMENT_SIZE];

int getvar(const char *varname, int defaultvalue) {
  if(!strcasecmp(varname, ""ERRORLEVEL"")) return errorlevel;
  
  for(int i = 0; i < ENVIRONMENT_SIZE; i++) {
    if(!strcmp(cmdenv[i].key, varname)) {
      return strtol(cmdenv[i].value, NULL, 0);
    }
  }
  return defaultvalue;
}

char* getvar(const char *varname, char *defaultvalue) {
  if(!strcasecmp(varname, ""ERRORLEVEL"")) return NULL;

  for(int i = 0; i < ENVIRONMENT_SIZE; i++) {
    if(!strcasecmp(cmdenv[i].key, varname)) {
      return cmdenv[i].value;
    }
  }
  return defaultvalue;
}

void setvarcmd(int argc, char **argv) {
  int i;
  
  if(argc != 3) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Syntax error in setvar command.\\r\\n"");
    return;
  }

  if(!strcasecmp(argv[1], ""ERRORLEVEL"")) return;

  // Find existing variable matching name and replace it
  for(i = 0; i < ENVIRONMENT_SIZE; i++) {
    if(!strcasecmp(cmdenv[i].key, argv[1])) {
      strncpy(cmdenv[i].value, argv[2], ENVIRONMENT_VALUE_SIZE);
      cmdenv[i].value[ENVIRONMENT_VALUE_SIZE-1] = 0;

      return;
    }
  }  

  // Create new variable if we have room.
  for(i = 0; i < ENVIRONMENT_SIZE; i++) {
    if(cmdenv[i].key[0] == 0) {
      strncpy(cmdenv[i].key, argv[1], ENVIRONMENT_KEY_SIZE);
      cmdenv[i].key[ENVIRONMENT_KEY_SIZE-1] = 0;

      strncpy(cmdenv[i].value, argv[2], ENVIRONMENT_VALUE_SIZE);
      cmdenv[i].value[ENVIRONMENT_VALUE_SIZE-1] = 0;

      return;
    }
  }

  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Ran out of environment variable space.\\r\\n"");
}

void unsetvarcmd(int argc, char **argv) {
  int i;
  
  if(argc != 2) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Syntax error in unsetvar command.\\r\\n"");
    return;
  }

  if(!strcasecmp(argv[1], ""ERRORLEVEL"")) return;

  // Find existing variable matching name and delete it
  for(i = 0; i < ENVIRONMENT_SIZE; i++) {
    if(!strcasecmp(cmdenv[i].key, argv[1])) {
      memset(cmdenv[i].key, 0, ENVIRONMENT_KEY_SIZE);
      memset(cmdenv[i].value, 0, ENVIRONMENT_VALUE_SIZE);

      return;
    }
  }

  // Quietly fail if the variable doesn't exist
}

void getvarcmd(int argc, char **argv) {
  int i;
  
  if(argc > 2) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Syntax error in getvar command.\\r\\n"");
    return;
  }

  if(!strcasecmp(argv[1], ""ERRORLEVEL"")) {
    Serial.printf(""%d\\r\\n"", errorlevel);
    return;
  }

  for(i = 0; i < ENVIRONMENT_SIZE; i++) {
    if(!strcasecmp(cmdenv[i].key, argv[1])) {
      Serial.printf(""%s=%s\\r\\n"", cmdenv[i].key, cmdenv[i].value);
      return;
    }
  }  

  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": variable '%s' not found.\\r\\n"", argv[1]);
  return;
}

void cmdParse(char *cmd) {
  uint8_t argc, i = 0;
  char *argv[MAXARG];

  // leading whitespace and blank lines are ignored
  while((*cmd == ' ') || (*cmd == '\\t')) cmd++;
	if(!cmd[0])	return;

  // ignore labels for regular command parsing
  if(cmd[0] == ':') return;

  // parse the statement and tokenize it (with quote handling)
  argv[i] = strmbtok(cmd, "" "", ""\\""'"", ""\\""'"");
  while ((argv[i] != NULL) && (i < MAXARG)) {
    // unquote the previous argument (last argument is always NULL)
    unquote(argv[i], argv[i]);
    argv[++i] = strmbtok(NULL, "" "", ""\\""'"", ""\\""'"");
  };
  
  // save the number of arguments
  argc = i;

  while(!strcasecmp(argv[0], ""if"")) {
    if(argc > 3) {
      int aval = getvar(argv[1], 0);
      int cval = strtol(argv[3], NULL, 0);
  
      if(!strcmp(argv[2], "">"")) {
        if(!(aval > cval)) return;
      } else if(!strcmp(argv[2], ""<"")) {
        if(!(aval < cval)) return;
      } else if(!strcmp(argv[2], "">="")) {
        if(!(aval >= cval)) return;
      } else if(!strcmp(argv[2], ""<="")) {
        if(!(aval <= cval)) return;
      } else if(!strcmp(argv[2], ""=="")) {
        if(!(aval == cval)) return;
      } else if(!strcmp(argv[2], ""!="")) {
        if(!(aval != cval)) return;
      } else {
        errorlevel = -1;
        Serial.print(""ERROR"");
        if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
        Serial.printf("": Unknown if conditional '%s'.\\r\\n"", argv[1]);
        return;
      }
  
      // condition met, parse rest of the line, skipping over ""then"" if present.
      if(!strcmp(argv[3], ""then"")) {
        argc -= 4;
        for(int iz=0; iz < argc; iz++) {
          argv[iz] = argv[iz+4];
        }
      } else {
        argc -= 3;
        for(int iz=0; iz < argc; iz++) {
          argv[iz] = argv[iz+3];
        }
      }
    } else {
      errorlevel = -1;
      Serial.print(""ERROR"");
      if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
      Serial.printf("": Not enough parameters to if command.\\r\\n"");
      return;
    }
  }

  // find the handler responsible for this command
  for(int ii=0; GlobalCommands[ii].Name; ii++) {
    if (!strcmp(argv[0], GlobalCommands[ii].Name)) {
      errorlevel = 0;
      GlobalCommands[ii].Func(argc, argv);
      return;
    }
  }

  // command not recognized. print message and re-generate prompt.
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Unknown command '%s'.\\r\\n"", argv[0]);
}

void cmd_handler() {
  char c = Serial.read();

  switch (c) {
    case '\\n':
      break;
    case '\\r':
      // terminate the msg and reset the msg ptr. then send
      // it to the handler for processing.
      *msg_ptr = '\\0';
      if(msg[0] != 0) {
        Serial.print(""\\r\\n"");
        cmdParse((char *)msg);
        execLoop();
        cmdDisplay();
      } else {
        Serial.print(""\\r\\n"");
        cmdDisplay();
      }
      msg_ptr = msg;
      break;
  
    case '\\b':
      // backspace 
      if (msg_ptr > msg)
      {
          *msg_ptr = '\\0';
          Serial.print(c);
          msg_ptr--;
      } else {
          Serial.print('\\x07');
          msg_ptr = msg;
          msg[0] = 0;
      }
      break;
  
    default:
      // normal character entered. add it to the buffer
      if(msg_ptr < (msg + sizeof(msg) - 1)) {
        Serial.print(c);
        *msg_ptr++ = c;
        *msg_ptr = '\\0';
      } else {
        Serial.print('\\x07');
      }
      break;
  }
}

void cmdPoll() {
  if (Serial.available()) {
    cmd_handler();
  }
}

void gotocmd(int argc, char **argv) {
  fspos_t tmp_pos;
  int tmp_line = 1;
  char tmp_cmd[256];
  if(scriptlevel < 0) {
    errorlevel = -1;
    Serial.printf(""ERROR: goto is only valid inside a script.\\r\\n"");
    return;
  }

  // Save our current position in case we can't find the label (should we exit the script on goto failure?)
  scriptstack[scriptlevel].m_file.fgetpos(&tmp_pos);

  // Rewind to the top of the script in case the label is up instead of down.
  scriptstack[scriptlevel].m_file.rewind();

  // Find the label
  while(scriptstack[scriptlevel].m_file.available()) {
    int n = scriptstack[scriptlevel].m_file.fgets(tmp_cmd, sizeof(tmp_cmd)-1, NULL);
    if (n <= 0) {
      Serial.printf(""Reading script '%s' failed at line %d.\\r\\n"", exec_filename, exec_line);
      
      break;
    }

    if(tmp_cmd[0] == ':') {
      if(!strcmp(tmp_cmd+1, argv[1])) {
        // Found it, script continues on the next line after the label. Update the line counter so any errors show the correct line reference.
        exec_line = tmp_line;
        return;
      }
    }
    tmp_line++;
  }

  // We couldn't find the label, restore the file position.
  scriptstack[scriptlevel].m_file.fsetpos(&tmp_pos);

  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Label '%s' was not found.\\r\\n"", argv[1]);
}

void exitcmd(int argc, char **argv) {
  if(scriptlevel < 0) {
    errorlevel = -1;
    Serial.printf(""ERROR: exit is only valid inside a script.\\r\\n"");
    return;
  }

  scriptstack[scriptlevel].m_file.close();
  exec_line = 0;
  scriptlevel--;
}

int execLoop() {
  char exec_cmd[256];
  while(scriptlevel >= 0) {
    if(scriptstack[scriptlevel].m_file.available()) {
      int n = scriptstack[scriptlevel].m_file.fgets(exec_cmd, sizeof(exec_cmd)-1, NULL);
      if (n <= 0) {
        Serial.printf(""Reading script '%s' failed at line %d.\\r\\n"", exec_filename, exec_line);
        goto close_file;
      }
      exec_cmd[sizeof(exec_cmd)-1] = 0;
      for(int ii = 0; ii < n; ii++) {
        if(exec_cmd[ii] == '\\r') exec_cmd[ii] = 0;
        if(exec_cmd[ii] == '\\n') exec_cmd[ii] = 0;
      }

      if(echo_on && exec_cmd[0]!='@') {
        cmdDisplay();
        Serial.printf(""%s\\r\\n"", exec_cmd);
      }

      if(exec_cmd[0] != '#')
        cmdParse((exec_cmd[0]!='@') ? exec_cmd : exec_cmd+1);

      exec_line++;
    } else {
close_file:
      scriptstack[scriptlevel].m_file.close();
      exec_line = 0;
      scriptlevel--;
    }
  }

  return 0;
}

void execscript(const char *script) {
  char tmp_path[MAX_FILE_PATH+1];
  char *filename = tmp_path;

  fixupPath(tmp_path, script);

  if(!strncmp(filename, ""/sd/"", 4)) {
    filename += 3;

    if(!sd.exists(filename)) {
      errorlevel = -1;
      Serial.print(""ERROR"");
      if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
      Serial.printf("": file '%s' not found.\\r\\n"", script);
      return;
    }
  } else {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": file '%s' not found.\\r\\n"", script);
    return;
  }

  if(scriptlevel >= MAX_SCRIPTLEVEL-1) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Script stack space exhausted.\\r\\n"");
    return;
  }

  scriptlevel++;
  scriptstack[scriptlevel].m_file = sd.open(filename, O_RDONLY);
  if(scriptstack[scriptlevel].m_file.isOpen()) {
    strcpy(exec_filename, script);
    exec_line = 1;
  } else {
    scriptlevel--;
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Unable to open script '%s'.\\r\\n"", script);
    return;
  }
}

void execcmd(int argc, char **argv) {
  if(argc > 1) {
    execscript(argv[1]);
  }
}

void echocmd(int argc, char **argv) {
  if(argc > 1) {
    if(!strcmp(""off"", argv[1])) {
      echo_on = 0;
    } else if(!strcmp(""on"", argv[1])) {
      echo_on = 1;
    } else {
      for(int i = 1; i<argc; i++) {
        Serial.printf(""%s "", argv[i]);
      }
      Serial.printf(""\\r\\n"");
    }
  }
}

void cmdCommandHelp(boolean singleCommand, Commands_t *table, int cmd) {
  if(!table) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Command table invalid.\\r\\n"");
    return;
  }
  if(singleCommand && table[cmd].FullHelp) {
    Serial.print(table[cmd].FullHelp);
  } else if(table[cmd].ShortHelp) {
    Serial.print(""\\r\\n"");
    Serial.print(table[cmd].Name);
    for(uint8_t i = 0; i < (16 - strlen(table[cmd].Name)); i++) {
      Serial.print("" "");
    }
    Serial.printf(""%s\\r\\n"", table[cmd].ShortHelp);
    if(table[cmd].MinParams) {
      Serial.printf(""                (Requires %d %s)\\r\\n"", table[cmd].MinParams, (table[cmd].MinParams>1) ? ""Parameters"" : ""Parameter"");
    }
    if(singleCommand)
      Serial.print(""\\r\\n"");
  }
}

void cmdDispatchHelp(Commands_t *table, int argc, char **argv) {
  if(!table) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": invalid command table.\\r\\n"");
    return;
  }
  if(argc<2) {
    for(int ii=0; table[ii].Name; ii++) {
      cmdCommandHelp(false, table, ii);
    }
    Serial.print(""\\r\\n"");
    return;
  }
  for(int ii=0; table[ii].Name; ii++) {
    if(!strcmp(argv[1], table[ii].Name)) {
      if(table[ii].Dispatch) {
        cmdDispatchHelp(table[ii].Dispatch, argc-1, &argv[1]);
      } else {
        cmdCommandHelp(true, table, ii);
      }
      return;
    }
  }
}

void clearcmd(int argc, char **argv) {
  Serial.printf(""\\x1b[2J\\x1b[H"");
}

void help(int argc, char **argv) {
  cmdDispatchHelp(GlobalCommands, argc, argv);
}

void cmdDispatch(Commands_t *table, int argc, char **argv) {
  int ii;

  if(!table) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Command table invalid.\\r\\n"");
    return;
  }

  argc--;
  if(argc<1) {
    for(ii=0; table[ii].Name; ii++) {
      cmdCommandHelp(false, table, ii);
    }
    return;
  }
  for(ii=0; table[ii].Name; ii++) {
    if(!strcmp(argv[1], table[ii].Name)) {
      if(argc < table[ii].MinParams) {
        errorlevel = -1;
        Serial.print(""ERROR"");
        if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
        Serial.printf("": Not enough parameters given\\r\\n"");
        return;
      }
      table[ii].Func(argc, &argv[1]);
    }
  }
}

void fixupPath(char *out, const char *in) {
  char *parent;

  char tmp_path[MAX_FILE_PATH+1];

  if(!in) return;
  if(!out) return;

  //unquote(tmp_path, in);
  strcpy(tmp_path, in);

  // Skip leading ""./"" if present
  if(!strncmp(tmp_path, ""./"", 2)) {
    sprintf(out, ""%s/%s"", cmd_prefix, tmp_path+2);
  } else if(!strcmp(tmp_path, "".."")) {
    // Ascend if ""..""
    strcpy(tmp_path, cmd_prefix);
    parent = strrchr(tmp_path, '/');
    if(parent && (tmp_path != parent)) {
      parent[0] = 0;
    }
    strcpy(out, tmp_path);
  } else if(*tmp_path == '/') {
    // Fully qualified path, replace everything
    strcpy(out, tmp_path);
  } else {
    // Relative path, append
    parent = strrchr(cmd_prefix, '/');
    if(parent[1] != 0) {
      sprintf(out, ""%s/%s"", cmd_prefix, tmp_path);
    } else {
      sprintf(out, ""%s%s"", cmd_prefix, tmp_path);
    }
  }

  // Make sure there is not a trailing /
  parent = strrchr(out, '/');
  if((parent != out) && (parent[1] == 0)) {
    parent[0] = 0;
  }
}

// Remove any command prefix levels
void changeDirectory(int argc, char **argv) {
  char new_prefix[256];
  char *suffix = NULL;

  if(argc>=2) {
    // Parse the path string
    fixupPath(new_prefix, argv[1]);

    if(!strncmp(""/vdevs/vdev"", new_prefix, 11)) {
      char *vdev_name = new_prefix + 11;
      uint8_t v = strtol(vdev_name, &suffix, 0);
      if((v < NUM_VDEV) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
        sprintf(cmd_prefix, ""/vdevs/vdev%d"", v);
        return;
      }
      goto e_invalidpath;
    }

    if(!strncmp(""/tgts/tgt"", new_prefix, 9)) {
      char *tgt_name = new_prefix + 9;
      char *lun_name = NULL;
      uint8_t id = strtol(tgt_name, &lun_name, 0);
      if(id < NUM_SCSIID) {
        if(!lun_name || (lun_name[0] == 0) || !strcmp(lun_name, ""/"")) {
          sprintf(cmd_prefix, ""/tgts/tgt%d"", id);
          return;
        } else if(!strncmp(""/lun"", lun_name, 4)) {
          lun_name += 4;
          uint8_t lun = strtol(lun_name, &suffix, 0);
          if((lun < NUM_SCSILUN) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
            sprintf(cmd_prefix, ""/tgts/tgt%d/lun%d"", id, lun);
            return;
          }
        }
      }
      goto e_invalidpath;
    }

    if(!strcmp(new_prefix, ""/"") || !strcmp(new_prefix, ""/tgts"") || !strcmp(new_prefix, ""/vdevs"")
       || !strcmp(new_prefix, ""/sd"") || !strcmp(new_prefix, ""/diag"")|| !strcmp(new_prefix, ""/diag/sd"")
    ) {
      strcpy(cmd_prefix, new_prefix);
      return;
    } else if(!strncmp(new_prefix, ""/sd/"", 4)) {
      if((new_prefix[4] == 0) || sd.exists(new_prefix+3)) {
        strcpy(cmd_prefix, new_prefix);
        return;
      }
    }

e_invalidpath:
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Path '%s' not found.\\r\\n"", new_prefix);
  } else {
    Serial.printf(""%s\\r\\n"", cmd_prefix);
  }
}

char tmp_left[256];
char tmp_right[256];

void printDirectory(int level, uint8_t lines, const char *l, const char *r) {
  for(int pad = 0; pad < level; pad++) {
    if(lines & (1 << (level - pad))) {
      Serial.print(""| "");
    } else {
      Serial.print(""  "");
    }
  }
  Serial.print(""o- "");
  int dots = 78 - ((level*2) + 3 + strlen(l) + strlen(r));
  Serial.print(l);
  while(dots--) {
    Serial.print(""."");
  }
  Serial.print(r);
  Serial.print(""\\r\\n"");
}

void showVDEV(int level, uint8_t lines, uint8_t v) {
  VirtualDevice_t *h = &m_vdev[v];
  if(h->m_enabled) {
    sprintf(tmp_left, ""vdev%d/ "", v);
    printDirectory(level, lines, tmp_left, "" [...]"");

    level++;
    lines<<=1;
    lines|=1;

    switch(h->m_type) {
      case DEV_DISK:
        strcpy(tmp_right, "" [disk]"");
        break;
      case DEV_OPTICAL:
        strcpy(tmp_right, "" [optical]"");
        break;
      case DEV_TAPE:
        strcpy(tmp_right, "" [tape]"");
        break;
      default:
        strcpy(tmp_right, "" [unknown]"");
        break;
    }
    printDirectory(level, lines, ""$type "", tmp_right);

    if((h->m_id < NUM_SCSIID) && (h->m_lun < NUM_SCSILUN)) {
      sprintf(tmp_right, "" [/tgts/tgt%d/lun%d]"", h->m_id, h->m_lun);
      printDirectory(level, lines, ""$mapping"", tmp_right);
    }
    if(h->m_file) {
      sprintf(tmp_right, "" [%s]"", h->m_filename);
      printDirectory(level, lines, ""$filename "", tmp_right);
    }
    if((h->m_fileSize) && (h->m_blocksize)) {
      sprintf(tmp_right, "" [%llu]"", h->m_fileSize / h->m_blocksize);
      printDirectory(level, lines, ""$blocks "", tmp_right);
    }
    if(h->m_blocksize) {
      sprintf(tmp_right, "" [%d]"", h->m_blocksize);
      printDirectory(level, lines, ""$blocksize "", tmp_right);
    }
  }
}

void showLUN(int level, uint8_t lines, uint8_t id, uint8_t lun) {
  if(!level) {
    sprintf(tmp_left, ""/tgts/tgt%d/lun%d/ "", id, lun);
  } else {
    sprintf(tmp_left, ""lun%d/ "", lun);
  }
  uint8_t v = m_vdevmap[id][lun];
  if(v < NUM_VDEV) {
    printDirectory(level, lines, tmp_left, "" [...]"");

    level++;
    lines <<= 1;
    lines |= 1;
    sprintf(tmp_right, "" [/vdevs/vdev%d]"", v);
    printDirectory(level, lines, ""$mapping"", tmp_right);
  }
}

void showTarget(int level, uint8_t lines, uint8_t id) {
  if(!level) {
    sprintf(tmp_left, ""/tgts/tgt%d/ "", id);
  } else {
    sprintf(tmp_left, ""tgt%d/ "", id);
  }
  if(scsi_id_mask & (1<<id)) {
    printDirectory(level, lines, tmp_left, "" [...]"");

    level++;
    lines <<= 1;
    lines |= 1;
    for(uint8_t lun = 0; lun < NUM_SCSILUN; lun++) {
      showLUN(level, lines, id, lun);
    }
  } else {
    printDirectory(level, lines, tmp_left, "" [DISABLED]"");
  }
}

void showDirectory(int argc, char **argv) {
  char *local_prefix = cmd_prefix;
  char tmp_prefix[256];
  char *suffix = NULL;
  uint8_t v;

  if(argc == 2) {
    fixupPath(tmp_prefix, argv[1]);
    local_prefix = tmp_prefix;
  }
  if(!strcmp(local_prefix, ""/"")) {
    printDirectory(0, 0, ""/ "", "" [...]"");
    printDirectory(1, 0, ""diag/ "", "" [...]"");
    printDirectory(1, 0, ""sd/ "", "" [...]"");
    sprintf(tmp_right, "" [%d Target%s]"", NUM_SCSIID, (NUM_SCSIID != 1) ? ""s"" : """");
    printDirectory(1, 0, ""tgts/ "", tmp_right);
    sprintf(tmp_right, "" [%d Storage Object%s]"", m_vdevcnt, (m_vdevcnt != 1) ? ""s"" : """");
    printDirectory(1, 0, ""vdevs/ "", tmp_right);
    return;
  }
  if(!strcmp(local_prefix, ""/diag"")) {
    printDirectory(0, 0, ""/diag/ "", "" [...]"");
    printDirectory(1, 0, ""sd/ "", "" [...]"");
    return;
  }
  if(!strcmp(local_prefix, ""/diag/sd"")) {
    printDirectory(0, 0, ""/diag/sd/ "", "" [...]"");

    sprintf(tmp_right, "" [SdFat %s]"", SD_FAT_VERSION_STR);
    printDirectory(1, 0, ""$version "", tmp_right);

    switch(SDFAT_FILE_TYPE) {
      case 0:
        strcpy(tmp_right, "" [FAT16]"");
        break;
      case 1:
        strcpy(tmp_right, "" [FAT16/FAT32]"");
        break;
      case 2:
        strcpy(tmp_right, "" [ExFAT]"");
        break;
      case 3:
        strcpy(tmp_right, "" [FAT16/FAT32/ExFAT]"");
        break;
    }
    printDirectory(1, 0, ""$filesystems "", tmp_right);

    sprintf(tmp_right, "" [%d]"", MAX_FILE_PATH);
    printDirectory(1, 0, ""$max_filename_length "", tmp_right);

    csd_t sd_csd;
    if(sd.card()->readCSD(&sd_csd))
    {
      switch (sd.card()->type()) {
        case SD_CARD_TYPE_SD1:
          strcpy(tmp_right, "" [SD1]"");
          break;
        case SD_CARD_TYPE_SD2:
          strcpy(tmp_right, "" [SD2]"");
          break;
        case SD_CARD_TYPE_SDHC:
          if (sdCardCapacity(&sd_csd) < 70000000) {
            strcpy(tmp_right, "" [SDHC]"");
          } else {
            strcpy(tmp_right, "" [SDXC]"");
          }
          break;
        default:
          strcpy(tmp_right, "" [unknown]"");
          break;
      }
      printDirectory(1, 0, ""$card_type "", tmp_right);

      uint32_t cardsize = 0.000512 * sdCardCapacity(&sd_csd);
      if(cardsize >= 10000) {
        sprintf(tmp_right, "" [%lu GB]"", cardsize);
      } else {
        sprintf(tmp_right, "" [%lu MB]"", cardsize);
      }
      printDirectory(1, 0, ""$card_size "", tmp_right);
    }
    cid_t sd_cid;
    if(sd.card()->readCID(&sd_cid))
    {
      sprintf(tmp_right, "" [0x%02X]"", sd_cid.mid);
      printDirectory(1, 0, ""$card_manufacturer "", tmp_right);

      sprintf(tmp_right, "" [%c%c]"", sd_cid.oid[0], sd_cid.oid[1]);
      printDirectory(1, 0, ""$card_oem "", tmp_right);

      sprintf(tmp_right, "" [%c%c%c%c%c]"", sd_cid.pnm[0], sd_cid.pnm[1], sd_cid.pnm[2], sd_cid.pnm[3], sd_cid.pnm[4]);
      printDirectory(1, 0, ""$card_name "", tmp_right);

      sprintf(tmp_right, "" [%d.%d]"", sd_cid.prv_n, sd_cid.prv_m);
      printDirectory(1, 0, ""$card_version "", tmp_right);

      sprintf(tmp_right, "" [%02d/20%02d]"", sd_cid.mdt_month, (sd_cid.mdt_year_high << 4) | sd_cid.mdt_year_low);
      printDirectory(1, 0, ""$card_date "", tmp_right);

      sprintf(tmp_right, "" [%08lX]"", sd_cid.psn);
      printDirectory(1, 0, ""$card_serial "", tmp_right);
    }
    return;
  }  
  if(!strcmp(local_prefix, ""/tgts"")) {
    sprintf(tmp_right, "" [%d Target%s]"", NUM_SCSIID, (NUM_SCSIID != 1) ? ""s"" : """");
    printDirectory(0, 0, ""/tgts/ "", tmp_right);
    for(uint8_t id = 0; id < NUM_SCSIID; id++) {
      showTarget(1, 1, id);
    }
    return;
  }
  if(!strncmp(local_prefix, ""/tgts/tgt"", 9)) {
    char *tgt_name = local_prefix + 9;
    char *lun_name = NULL;
    uint8_t id = strtol(tgt_name, &lun_name, 0);
    if(id < NUM_SCSIID) {
      if(!lun_name || (lun_name[0] == 0) || !strcmp(lun_name, ""/"")) {
        showTarget(0, 0, id);
        return;
      } else if(!strncmp(""/lun"", lun_name, 4)) {
        lun_name += 4;
        uint8_t lun = strtol(lun_name, &suffix, 0);
        if((lun < NUM_SCSILUN) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
          showLUN(0, 0, id, lun);
          return;
        }
      }
    }
  }
  
  if(!strcmp(local_prefix, ""/vdevs"")) {
    sprintf(tmp_right, "" [%d Storage Objects]"", m_vdevcnt);
    printDirectory(0, 0, ""/vdevs/ "", tmp_right);
    for(v = 0; v < NUM_VDEV; v++) {
      showVDEV(1, 1, v);
    }
    return;
  }
  if(!strncmp(local_prefix, ""/vdevs/vdev"", 11)) {
    char *vdev_name = local_prefix + 11;
    v = strtol(vdev_name, &suffix, 0);
    if((v < NUM_VDEV) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
      showVDEV(0, 0, v);
      return;
    }
  }
  if(!strcmp(local_prefix, ""/sd"") || !strncmp(local_prefix, ""/sd/"", 4)) {
    char name[MAX_FILE_PATH+1];
    SdFile root;
    SdFile file;
    if(!strcmp(local_prefix, ""/sd""))
      strcat(local_prefix, ""/"");
    root.open(local_prefix+3);
    if(!root.isDir()) {
      sprintf(tmp_left, ""%s "", local_prefix);
      if(root.fileSize() >= 2000000000) {
        sprintf(tmp_right, "" [%llu GB]"", root.fileSize() / 1000000000);
      } else if(root.fileSize() >= 2000000) {
        sprintf(tmp_right, "" [%llu MB]"", root.fileSize() / 1000000);
      } else if(root.fileSize() >= 2000) {
        sprintf(tmp_right, "" [%llu KB]"", root.fileSize() / 1000);
      } else {
        sprintf(tmp_right, "" [%llu Bytes]"", root.fileSize());
      }
      printDirectory(0, 0, tmp_left, tmp_right);
      root.close();
      return;
    }
    sprintf(tmp_left, ""%s "", local_prefix);
    printDirectory(0, 0, tmp_left, "" [...]"");

    while(file.openNext(&root, O_READ)) {
      file.getName(name, MAX_FILE_PATH+1);
      if(file.isDir()) {
        sprintf(tmp_left, ""%s/ "", name);
        printDirectory(1, 0, tmp_left, "" [...]"");
      } else {
        sprintf(tmp_left, ""%s "", name);
        if(file.fileSize() >= 2000000000) {
          sprintf(tmp_right, "" [%llu GB]"", file.fileSize() / 1000000000);
        } else if(file.fileSize() >= 2000000) {
          sprintf(tmp_right, "" [%llu MB]"", file.fileSize() / 1000000);
        } else if(file.fileSize() >= 2000) {
          sprintf(tmp_right, "" [%llu KB]"", file.fileSize() / 1000);
        } else {
          sprintf(tmp_right, "" [%llu Bytes]"", file.fileSize());
        }
        printDirectory(1, 0, tmp_left, tmp_right);
      }
      file.close();
    }
    root.close();
    return;
  }

  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Path '%s' not found.\\r\\n"", local_prefix);
}

void unlinkcmd(int argc, char **argv) {
  FsFile file;            /* File object */
  char tmp_path[MAX_FILE_PATH+1];
  char *vdev_name = NULL;
  char *tgt_name = NULL;
  char *lun_name = NULL;
  char *suffix = NULL;
  uint8_t v = 0xff;
  uint8_t id = 0xff;
  uint8_t lun = 0xff;
  VirtualDevice_t *h = NULL;
  
  if(argc < 2) {
    return;
  }

  fixupPath(tmp_path, argv[1]);

  if(!strncmp(""/tgts/tgt"", tmp_path, 9)) {
    tgt_name = tmp_path + 9;
    id = strtol(tgt_name, &lun_name, 0);
    if(id < NUM_SCSIID) {
      if((lun_name) && !strncmp(""/lun"", lun_name, 4)) {
        // Disable a specific LUN
        lun_name += 4;
        lun = strtol(lun_name, &suffix, 0);
        if((lun < NUM_SCSILUN) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
          v = m_vdevmap[id][lun];
          if(v < NUM_VDEV) {
            h = &m_vdev[v];
            h->m_id = 0xff;
            h->m_lun = 0xff;
            m_vdevmap[id][lun] = 0xff;
            return;
          }
        }
      } else if(!lun_name || (lun_name[0] == 0) || !strcmp(lun_name, ""/"")) {
        // Disable this target and all LUNs under it
        scsi_id_mask &= ~(1 << id);
        for(lun = 0; lun < NUM_SCSILUN; lun++) {
          v = m_vdevmap[id][lun];
          if(v < NUM_VDEV) {
            h = &m_vdev[v];
            h->m_id = 0xff;
            h->m_lun = 0xff;
            m_vdevmap[id][lun] = 0xff;
          }
        }
        return;
      }
    }
  }
  if(!strncmp(""/vdevs/vdev"", tmp_path, 11)) {
    vdev_name = tmp_path + 11;
    v = strtol(vdev_name, &suffix, 0);
    if((v < NUM_VDEV) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
      id = h->m_id;
      lun = h->m_lun;
      
      h = &m_vdev[v];
      h->m_id = 0xff;
      h->m_lun = 0xff;

      if((id < NUM_SCSIID) && (lun < NUM_SCSILUN))
        m_vdevmap[id][lun] = 0xff;
      
      return;
    }
  }

  if(!strncmp(tmp_path, ""/sd/"", 4)) {
    sd.remove(tmp_path+3);
    return;
  }

  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Path '%s' not found.\\r\\n"", tmp_path);
}

void makeimagecmd(int argc, char **argv) {
  FsFile file;
  char tmp_path[MAX_FILE_PATH+1];
  uint64_t fileSize = 0;
  
  if(argc < 4) {
    return;
  }

  fixupPath(tmp_path, argv[1]);
  if(strncmp(tmp_path, ""/sd/"", 4)) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Can only create images on the SD Card.\\r\\n"");
    return;
  }

  if(!strcmp(argv[2], ""msdos"") || !strcmp(argv[2], ""generic"")) {
    char *suffix = NULL;
    fileSize = strtoul(argv[3], &suffix, 0);
    if(suffix && suffix[0] != 0) {
      if(!strcmp(suffix, ""KB"")) fileSize *= 1000ull;
      if(!strcmp(suffix, ""KiB"")) fileSize *= 1024ull;
      if(!strcmp(suffix, ""MB"")) fileSize *= 1000000ull;
      if(!strcmp(suffix, ""MiB"")) fileSize *= 1024ull * 1024ull;
      if(!strcmp(suffix, ""GB"")) fileSize *= 1000000000ull;
      if(!strcmp(suffix, ""GiB"")) fileSize *= 1024ull * 1024ull * 1024ull;
    }

    if(sd.exists(tmp_path+3)) {
      errorlevel = -1;
      Serial.print(""ERROR"");
      if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
      Serial.printf("": file '%s' already exists.\\r\\n"", tmp_path);
      return;
    }
    if(fileSize < (5ull * 1024ull * 1024ull)) {
      errorlevel = -1;
      Serial.print(""ERROR"");
      if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
      Serial.printf("": Image would be less than 5 MiB.\\r\\n"");
      return;
    }
    if(fileSize > (2048ull * 1024ull * 1024ull)) {
      errorlevel = -1;
      Serial.print(""ERROR"");
      if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
      Serial.printf("": Image would be larger than 2 GiB.\\r\\n"");
      return;
    }

    // Fixup image size to our 64 Head 32 Sector X Cylinders formula
    uint64_t cyl = fileSize / (512ull * 64ull * 32ull);
    if(fileSize & 0xFFFFF) cyl++;
    if(cyl > 2048) cyl = 2048;
    fileSize = cyl * (512ull * 64ull * 32ull);

    if(!file.open(tmp_path+3, O_WRONLY | O_CREAT | O_TRUNC)) {
      errorlevel = -1;
      Serial.print(""ERROR"");
      if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
      Serial.printf("": Unable to open '%s'.\\r\\n"", tmp_path);
    } else {
      // Take advantage of our cylinders being 1MB
      if(!file.preAllocate(cyl)) {
        file.close();
        sd.remove(tmp_path+3);

        errorlevel = -1;
        Serial.print(""ERROR"");
        if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
        Serial.printf("": Pre-allocate failed, SD Card must be formatted as ExFat.\\r\\n"");
        return;
      }

      if(!strcmp(argv[2], ""msdos"")) {
        file.write(mbr_bin, 512);
      }
      file.close();

      return;
    }
  }

  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Unable to process command as requested.\\r\\n"");
  return;
}

void catcmd(int argc, char **argv) {
  FsFile file;            /* File object */
  char tmp_path[MAX_FILE_PATH+1];
  char tmp_str[256];
  char *filename = tmp_path;
  
  if(argc < 2) {
    return;
  }

  fixupPath(tmp_path, argv[1]);
  if(!strncmp(filename, ""/sd/"", 4)) {
    filename += 3;
  } else {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": file '%s' not found.\\r\\n"", tmp_path);
    return;
  }

  if(!sd.exists(filename)) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": file '%s' not found.\\r\\n"", tmp_path);
    return;
  }

  if(!file.open(filename, O_RDONLY)) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Unable to open '%s'.\\r\\n"", tmp_path);
  } else {
    while(file.available()) {
      int n = file.fgets(tmp_str, sizeof(tmp_str)-1, NULL);
      if (n <= 0) {
        errorlevel = -1;
        Serial.print(""ERROR"");
        if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
        Serial.printf("": Reading '%s' failed.\\r\\n"", tmp_path);
        
        break;
      }

      Serial.print(tmp_str);
    }
    file.close();
  }
}

void enablecmd(int argc, char **argv) {
  uint8_t id = 0xff;
  char *tgt_name = NULL;
  char *suffix;
  char tmp_path[MAX_FILE_PATH+1];

  // The logic here is slightly complicated to allow specifying enable /tgts/tgtN from anywhere, but otherwise require we are in /tgts
  if((argc<2) && strncmp(""/tgts"", cmd_prefix, 5)) {
    goto e_invalidpath;
  }

  if((argc<2) && !strcmp(""/tgts"", cmd_prefix)) {
    goto e_notarget;
  }

  if(argc<2) {
    strcpy(tmp_path, cmd_prefix);
  } else {
    fixupPath(tmp_path, argv[1]);
  }

  if(strncmp(""/tgts/"", tmp_path, 6)) {
    goto e_invalidpath;
  }
  if(!strncmp(""/tgts/tgt"", tmp_path, 9)) {
    tgt_name = tmp_path + 9;
    id = strtol(tgt_name, &suffix, 0);
  }

  if(id < NUM_SCSIID) {
    scsi_id_mask |= (1<<id);
    return;
  }

//e_invalidtarget:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": Invalid target specified.\\r\\n"");
  return;

e_invalidpath:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": The enable command is not valid in this context.\\r\\n"");
  return;

e_notarget:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": No target specified.\\r\\n"");
  return;
}

void setcmd(int argc, char **argv) {
  uint8_t v = 0xff;
  char *vdev_name = NULL;
  char *param_name = NULL;

  char tmp_path[MAX_FILE_PATH+1];

  if(argc<2) {
    goto e_syntax;
  }

  fixupPath(tmp_path, argv[1]);

  // Allow specifying set /vdevs/vdevN/parameter from anywhere, but otherwise require we are in /vdevs/vdevN
  if(!strncmp(""/global"", tmp_path, 7)) {
    param_name = tmp_path + 7;

    if(!strcasecmp(param_name, ""/quirks"")) {
      if(argc<3) {
        Serial.printf(""0x%02x\\r\\n"", default_quirks);
      } else {
        default_quirks = strtol(argv[2], NULL, 0);
      }
      return;
    }
  }
  
  // Allow specifying set /vdevs/vdevN/parameter from anywhere, but otherwise require we are in /vdevs/vdevN
  if(!strncmp(""/vdevs/vdev"", tmp_path, 11)) {
    vdev_name = tmp_path + 11;
    v = strtol(vdev_name, &param_name, 0);

    if(v < NUM_VDEV) {
      VirtualDevice_t *h = &m_vdev[v];

      if((param_name) && !strcasecmp(param_name, ""/blocksize"")) {
        if(argc<3) {
          Serial.printf(""%d\\r\\n"", h->m_blocksize);
        } else {
          h->m_blocksize = strtol(argv[2], NULL, 0);
        }
        return;
      }

      if((param_name) && !strcasecmp(param_name, ""/quirks"")) {
        if(argc<3) {
          Serial.printf(""0x%02x\\r\\n"", h->m_quirks);
        } else {
          h->m_quirks = strtol(argv[2], NULL, 0);
        }
        return;
      }

      if((param_name) && !strcasecmp(param_name, ""/type"")) {
        if(argc<3) {
          switch(h->m_type) {
            case DEV_DISK:
              strcpy(tmp_right, "" [disk]"");
              break;
            case DEV_OPTICAL:
              strcpy(tmp_right, "" [optical]"");
              break;
            case DEV_TAPE:
              strcpy(tmp_right, "" [tape]"");
              break;
            default:
              strcpy(tmp_right, "" [unknown]"");
              break;
          }
          printDirectory(0, 0, ""$type "", tmp_right);
        } else {
#if SUPPORT_DISK
          if(!strcasecmp(argv[2], ""disk"")) {
            ConfigureDisk(h, NULL);
            return;
          }
#endif /* SUPPORT_DISK */
#if SUPPORT_OPTICAL
          if(!strcasecmp(argv[2], ""optical"") || !strcasecmp(argv[2], ""cdrom"")) {
            ConfigureOptical(h, NULL);
            return;
          }
#endif /* SUPPORT_OPTICAL */
#if SUPPORT_TAPE
          if(!strcasecmp(argv[2], ""tape"")) {
            ConfigureTape(h, NULL);
            return;
          }
#endif /* SUPPORT_TAPE */
        }
        goto e_invalidvalue;
      }

      goto e_invalidparam;
    }
    goto e_invalidpath;
  }

e_invalidpath:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": The set command is not valid in this context.\\r\\n"");
  return;

e_invalidparam:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Invalid parameter '%s' specified.\\r\\n"", param_name);
  return;

e_invalidvalue:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Invalid value '%s' for parameter '%s' specified.\\r\\n"", argv[2], param_name);
  return;

e_syntax:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": Command syntax violation.\\r\\n"");
  return;
}

void createcmd(int argc, char **argv) {
  if(strncmp(""/vdev"", cmd_prefix, 5)) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.print("": The create command is not valid in this context.\\r\\n"");
    return;
  }

  if(m_vdevcnt >= NUM_VDEV) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.print("": Virtual Device pool exhausted.\\r\\n"");
    return;
  }

  if(argc<2) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.print("": No device type specified.\\r\\n"");
    return;
  }

  uint8_t v = m_vdevcnt;
  VirtualDevice_t *h = &m_vdev[v];

  h->m_quirks = default_quirks;

#if SUPPORT_DISK
  if(!strcasecmp(argv[1], ""disk"")) {
    ConfigureDisk(h, NULL);
    goto success;
  }
#endif /* SUPPORT_DISK */
#if SUPPORT_OPTICAL
  if(!strcasecmp(argv[1], ""optical"") || !strcasecmp(argv[1], ""cdrom"")) {
    ConfigureOptical(h, NULL);
    goto success;
  }
#endif /* SUPPORT_OPTICAL */
#if SUPPORT_TAPE
  if(!strcasecmp(argv[1], ""tape"")) {
    ConfigureTape(h, NULL);
    goto success;
  }
#endif /* SUPPORT_TAPE */

//failure:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": Unknown device type specified.\\r\\n"");
  return;

success:
  sprintf(cmd_prefix, ""/vdevs/vdev%d"", v);
  h->m_enabled = true;
  h->m_id = 0xff;
  h->m_lun = 0xff;
  m_vdevcnt++;
}

void mountcmd(int argc, char **argv) {
  char tmp_path[MAX_FILE_PATH+1];
  char *vdev_name = NULL;
  VirtualDevice_t *h;
  uint8_t v = 0xff;
  
  if(!strncmp(""/vdevs/vdev"", cmd_prefix, 11)) {
    vdev_name = cmd_prefix + 11;
    v = strtol(vdev_name, NULL, 0);
  }

  if(v < NUM_VDEV) {
    h = &m_vdev[v];
    if(h->m_blocksize == 0) {
      if(h->m_type == DEV_TAPE) {
        h->m_blocksize = 1024;
      } else {
        h->m_blocksize = 512;
      }
    }
  } else if(argc>=2) {
    errorlevel = -1;
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.print("": The mount command is not valid in this context.\\r\\n"");
    return;
  } else {
    // TODO: Print out all mounted images
    return;
  }

  if(argc<2) {
    // TODO: Print out the mounted image
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.print("": No backingstore specified.\\r\\n"");
    return;
  }

  fixupPath(tmp_path, argv[1]);

  if(!strncmp(tmp_path, ""/sd/"", 4)) {
    if(OpenDiskImage(h, tmp_path, 512)) {
      strcpy(h->m_filename, tmp_path);
      h->m_enabled = true;
      
      return;
    }
  }

  h->m_fileSize = 0;
  h->m_blocksize = 0;
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": Unsupported backingstore path.\\r\\n"");
  return;
}


void mapcmd(int argc, char **argv) {
  char tmp_path[MAX_FILE_PATH+1];
  char *vdev_name = NULL;
  char *tgt_name = NULL;
  char *lun_name = NULL;
  char *suffix = NULL;
  VirtualDevice_t *h;
  uint8_t v = 0xff;
  uint8_t id = 0xff;
  uint8_t lun = 0xff;
  
  if(!strncmp(""/vdevs/vdev"", cmd_prefix, 11)) {
    vdev_name = cmd_prefix + 11;
    v = strtol(vdev_name, &suffix, 0);

    if((v < NUM_VDEV) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
      h = &m_vdev[v];
      if(argc>=2) {
        fixupPath(tmp_path, argv[1]);

        if(!strncmp(""/tgts/tgt"", tmp_path, 9)) {
          tgt_name = tmp_path + 9;
          id = strtol(tgt_name, &lun_name, 0);
          if((id < NUM_SCSIID) && (lun_name)) {
            if(!strncmp(""/lun"", lun_name, 4)) {
              lun_name += 4;
              lun = strtol(lun_name, &suffix, 0);
              if((lun < NUM_SCSILUN) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
                h->m_id = id;
                h->m_lun = lun;
                m_vdevmap[id][lun] = v;
                return;
              }
            }
          }
        }
        goto e_invalidtarget;
      } else {
        sprintf(tmp_left, ""/vdevs/vdev%d/$mapping "", v);
        sprintf(tmp_right, "" [/tgts/tgt%d/lun%d]\\r\\n"", h->m_id, h->m_lun);
        printDirectory(0, 0, tmp_left, tmp_right);
        return;
      }
    }
  }
  if(!strncmp(""/tgts/tgt"", cmd_prefix, 9)) {
    tgt_name = cmd_prefix + 9;
    id = strtol(tgt_name, &lun_name, 0);
    if((id < NUM_SCSIID) && (lun_name)) {
      if(!strncmp(""/lun"", lun_name, 4)) {
        lun_name += 4;
        lun = strtol(lun_name, &suffix, 0);
        if((lun < NUM_SCSILUN) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
          if(argc>=2) {
            fixupPath(tmp_path, argv[1]);
            
            if(!strncmp(""/vdevs/vdev"", tmp_path, 11)) {
              vdev_name = cmd_prefix + 11;
              v = strtol(vdev_name, &suffix, 0);
          
              if((v < NUM_VDEV) && (!suffix || (suffix[0] == 0) || !strcmp(suffix, ""/""))) {
                h = &m_vdev[v];
                h->m_id = id;
                h->m_lun = lun;
                m_vdevmap[id][lun] = v;
                return;
              }
            }
            goto e_invalidtarget;
          } else {
            v = m_vdevmap[id][lun];
            if(v < NUM_VDEV) {
              sprintf(tmp_left, ""/tgts/tgt%d/lun%d/$mapping "", id, lun);
              sprintf(tmp_right, "" [/vdevs/vdev%d]\\r\\n"", v);
              printDirectory(0, 0, tmp_left, tmp_right);
            }
            return;
          }
        }
      }
    }
  }

//e_invalidcontext:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.print("": The map command is not valid in this context.\\r\\n"");
  return;

e_invalidtarget:
  errorlevel = -1;
  Serial.print(""ERROR"");
  if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
  Serial.printf("": Invalid target '%s' specified.\\r\\n"", tmp_path);
  return;
}

void saveconfig(int argc, char **argv) {
  FsFile config_file;

  config_file = sd.open(""/greenscsi.cfg"", O_WRONLY | O_CREAT | O_TRUNC);
  if(!config_file.isOpen()) {
    Serial.print(""ERROR"");
    if(scriptlevel >= 0) Serial.printf("" on line %d of '%s'"", exec_line, exec_filename);
    Serial.printf("": Unable to open 'greenscsi.cfg' for writing.\\r\\n"");
    return;
  }
  config_file.print( ""@echo off\\r\\n\\r\\n"");

  if(scsi_id_mask != 0) {
    config_file.print( ""cd /tgts\\r\\n"");
    for(uint8_t id = 0; id < NUM_SCSIID; id++) {
      if(scsi_id_mask & (1<<id)) {
        config_file.printf(""enable tgt%d\\r\\n"", id);
      }
    }
  }
  config_file.print( ""\\r\\n"");

  config_file.print( ""cd /vdevs\\r\\n"");
  for(uint8_t id = 0; id < NUM_SCSIID; id++) {
    for(uint8_t lun = 0; lun < NUM_SCSILUN; lun++) {
      uint8_t v = m_vdevmap[id][lun];
      if(v < NUM_VDEV) {
        VirtualDevice_t *h = &m_vdev[v];
        if(h->m_enabled) {
          // The create command automatically changes directory to the created object
          switch(h->m_type) {
            case DEV_DISK:
              config_file.print(""create disk\\r\\n"");
              break;
            case DEV_OPTICAL:
              config_file.print(""create optical\\r\\n"");
              break;
            case DEV_TAPE:
              config_file.print(""create tape\\r\\n"");
              break;
            default:
              config_file.printf(""create 0x%02x\\r\\n"", h->m_type);
              break;
          }
          if(h->m_file) {
            config_file.printf(""mount %s\\r\\n"", h->m_filename);
          }
          if(h->m_blocksize) {
            config_file.printf(""set blocksize %d\\r\\n"", h->m_blocksize);
          }
    
          // The map command should be last, as it will escape back to /vdevs
          if((h->m_id < NUM_SCSIID) && (h->m_lun < NUM_SCSILUN)) {
            config_file.printf(""map /tgts/tgt%d/lun%d\\r\\n"", h->m_id, h->m_lun);
          } else {
            config_file.print(""cd ..\\r\\n"");
          }
          config_file.print( ""\\r\\n"");
        }
      }
    }
  }
  config_file.close();
}

char helponSave[] =
  ""\\r\\n""
  ""saveconfig\\r\\n""
  ""\\r\\n""
  ""  Generate a new greenscsi.cfg file containing currently configured parameters.\\r\\n""
  ""Any existing greenscsi.cfg file will be overwritten and its previous contents lost.\\r\\n""
  ""\\r\\n""
;

char helponSet[] =
  ""\\r\\n""
  ""set <key> <value>\\r\\n""
  ""\\r\\n""
  ""  Use the set command to configure vdev parameters.\\r\\n""
  ""\\r\\n""
;

char helponCreate[] =
  ""\\r\\n""
  ""create <type>\\r\\n\\r\\n""
  ""  The create command allocates and changes the path to a newly created vdev.\\r\\n""
  ""Recognized values for type:""
#if SUPPORT_DISK
  "" disk""
#endif
#if SUPPORT_OPTICAL
  "" optical""
#endif
#if SUPPORT_TAPE
  "" tape""
#endif
  "".\\r\\n""
  ""You can also specify the SCSI device code value directly.\\r\\n""
  ""\\r\\n""
;

char helponEcho[] =
  ""\\r\\n""
  ""echo [on|off|<message>]\\r\\n""
  ""\\r\\n""
  ""  The echo command allows you to turn on or off the echoing of script commands to the console.\\r\\n""
  ""Additionally, you can use the echo command to relay a message to the console.\\r\\n""
  ""\\r\\n""
;

char helponCat[] =
  ""\\r\\n""
  ""cat <file>\\r\\n""
  ""\\r\\n""
  ""  The cat command dumps files to the console for reading.\\r\\n""
  ""\\r\\n""
;

char helponUnlink[] =
  ""\\r\\n""
  ""unlink <path>\\r\\n""
  ""\\r\\n""
  ""  The unlink command removes objects such as files or vdevs.\\r\\n""
  ""\\r\\n""
;

char helponExec[] =
  ""\\r\\n""
  ""exec <script>\\r\\n""
  ""\\r\\n""
  ""  The exec command executes command script files.\\r\\n""
  ""At startup, greenscsi.cfg will be executed from the sd card if found.\\r\\n""
  ""\\r\\n""
;

char helponEnable[] =
  ""\\r\\n""
  ""enable tgt<n>\\r\\n""
  ""\\r\\n""
  ""  The enable command sets a SCSI device ID to be handled by GreenSCSI.\\r\\n""
  ""\\r\\n""
;

char helponMapT[] =
  ""\\r\\n""
  ""map <vdev>\\r\\n""
  ""\\r\\n""
  ""  The map command associates a given vdev with this lun.\\r\\n""
  ""\\r\\n""
;

char helponMapV[] =
  ""\\r\\n""
  ""map <lun>\\r\\n""
  ""\\r\\n""
  ""  The map command associates a given lun with this vdev.\\r\\n""
  ""\\r\\n""
;

char helponMount[] =
  ""\\r\\n""
  ""mount <path>\\r\\n""
  ""\\r\\n""
  ""  The mount command associates a given image or block device with this vdev.\\r\\n""
  ""\\r\\n""
;

char helponVar[] =
  ""\\r\\n""
  ""setvar <key> <value>\\r\\n""
  ""unsetvar <key>\\r\\n""
  ""getvar <key>\\r\\n""
  ""\\r\\n""
  ""  The var commands allow you to perform rudementary environment variable manipulation.\\r\\n""
  ""\\r\\n""
;

char helponMkImg[] =
  ""\\r\\n""
  ""mkimg <file> <type> <size>\\r\\n""
  ""\\r\\n""
  ""  The mkimg command creates image files on ExFat volumes.\\r\\n""
  ""\\r\\n""
  ""<type> specifies the partitioning scheme to preload the image with.\\r\\n""
  ""       generic creates a blank disk ready for partitioning.\\r\\n""
  ""       msdos preloads an MBR boot menu, and in the future may pre-partition and format.\\r\\n""
  ""\\r\\n""
  ""<size> specifies file size and supports a KB,MB,GB (1000) or KiB,MiB,GiB (1024) suffix.\\r\\n""
  ""\\r\\n""
;

char helponHelp[] =
  ""\\r\\n""
  ""help\\r\\n""
  ""\\r\\n""
  ""  This help facility will show you the commands available within the current path.\\r\\n""
  ""Some commands may have longer help articles such as this one to describe their parameters fully.\\r\\n""
  ""\\r\\n""
;

Commands_t GlobalCommands[] = {
  // Command      Valid From Path   Req. Params    Short Help                    Long Help       Handler           Dispatch
  { ""cd"",         ""/"",              1,             ""change current directory"",   NULL,           changeDirectory,  NULL },
  { ""sl"",         ""/"",              0,             NULL,                         NULL,           slcmd,            NULL },
  { ""dir"",        ""/"",              0,             NULL,                         NULL,           punishDirectory,  NULL },
  { ""ls"",         ""/"",              0,             ""display directory contents"", NULL,           showDirectory,    NULL },
  { ""saveconfig"", ""/"",              0,             ""write greenscsi.cfg file"",   helponSave,     saveconfig,       NULL },
  { ""enable"",     ""/tgts"",          1,             ""<target>"",                   helponEnable,   enablecmd,        NULL },
  { ""map"",        ""/tgts/tgt"",      1,             ""<vdev>"",                     helponMapT,     mapcmd,           NULL },
  { ""create"",     ""/vdevs"",         1,             ""<type>"",                     helponCreate,   createcmd,        NULL },
  { ""set"",        ""/vdevs/vdev"",    2,             ""<key> <value>"",              helponSet,      setcmd,           NULL },
  { ""mount"",      ""/vdevs/vdev"",    1,             ""<path>"",                     helponMount,    mountcmd,         NULL },
  { ""map"",        ""/vdevs/vdev"",    1,             ""<lun>"",                      helponMapV,     mapcmd,           NULL },
  { ""cat"",        ""/sd"",            1,             ""<file>"",                     helponCat,      catcmd,           NULL },
  { ""mkimg"",      ""/sd"",            1,             ""<file>"",                     helponMkImg,    makeimagecmd,     NULL },
  { ""unlink"",     ""/"",              1,             ""<path>"",                     helponUnlink,   unlinkcmd,        NULL },
  { ""exec"",       ""/"",              1,             ""<script>"",                   helponExec,     execcmd,          NULL },
  { ""goto"",       ""/"",              1,             NULL,                         NULL,           gotocmd,          NULL },
  { ""exit"",       ""/"",              0,             NULL,                         NULL,           exitcmd,          NULL },
  { ""setvar"",     ""/"",              2,             ""<key> <value>"",              helponVar,      setvarcmd,        NULL },
  { ""getvar"",     ""/"",              0,             ""[key]"",                      helponVar,      getvarcmd,        NULL },
  { ""unsetvar"",   ""/"",              1,             ""<key>"",                      helponVar,      unsetvarcmd,      NULL },
  { ""echo"",       ""/"",              0,             ""[on|off|<message>]"",         helponEcho,     echocmd,          NULL },
  { ""clear"",      ""/"",              0,             ""Erase the screen"",           NULL,           clearcmd,         NULL },
  { ""help"",       ""/"",              0,             ""This help facility."",        helponHelp,     help,             NULL },
  { NULL,         NULL,             0,             NULL,                         NULL,           NULL,             NULL }
};
",16176,True,2994.5802673342237,median
"/*
Feathers
Copyright 2012-2021 Bowler Hat LLC. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.layout
{
	import feathers.core.IValidating;

	import flash.errors.IllegalOperationError;
	import flash.geom.Point;
	import flash.ui.Keyboard;

	import starling.display.DisplayObject;
	import starling.events.Event;

	/**
	 * Dispatched when a property of the layout changes, indicating that a
	 * redraw is probably needed.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @eventType starling.events.Event.CHANGE
	 */
	[Event(name=""change"",type=""starling.events.Event"")]

	/**
	 * Positions items of different dimensions from left to right in multiple
	 * rows. When the width of a row reaches the width of the container, a new
	 * row will be started. Constrained to the suggested width, the flow layout
	 * will change in height as the number of items increases or decreases.
	 *
	 * @see ../../../help/flow-layout.html How to use FlowLayout with Feathers containers
	 *
	 * @productversion Feathers 2.2.0
	 */
	public class FlowLayout extends BaseVariableVirtualLayout implements IVariableVirtualLayout, IDragDropLayout
	{
		/**
		 * Constructor.
		 */
		public function FlowLayout()
		{
			super();
			this._hasVariableItemDimensions = true;
		}

		/**
		 * @private
		 */
		protected var _rowItems:Vector.<DisplayObject> = new <DisplayObject>[];

		/**
		 * Quickly sets both <code>horizontalGap</code> and <code>verticalGap</code>
		 * to the same value. The <code>gap</code> getter always returns the
		 * value of <code>horizontalGap</code>, but the value of
		 * <code>verticalGap</code> may be different.
		 *
		 * @default 0
		 *
		 * @see #horizontalGap
		 * @see #verticalGap
		 */
		public function get gap():Number
		{
			return this._horizontalGap;
		}

		/**
		 * @private
		 */
		public function set gap(value:Number):void
		{
			this.horizontalGap = value;
			this.verticalGap = value;
		}

		/**
		 * @private
		 */
		protected var _horizontalGap:Number = 0;

		/**
		 * The horizontal space, in pixels, between items.
		 *
		 * @default 0
		 */
		public function get horizontalGap():Number
		{
			return this._horizontalGap;
		}

		/**
		 * @private
		 */
		public function set horizontalGap(value:Number):void
		{
			if(this._horizontalGap == value)
			{
				return;
			}
			this._horizontalGap = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _verticalGap:Number = 0;

		/**
		 * The vertical space, in pixels, between items.
		 *
		 * @default 0
		 */
		public function get verticalGap():Number
		{
			return this._verticalGap;
		}

		/**
		 * @private
		 */
		public function set verticalGap(value:Number):void
		{
			if(this._verticalGap == value)
			{
				return;
			}
			this._verticalGap = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _firstHorizontalGap:Number = NaN;

		/**
		 * The space, in pixels, between the first and second items. If the
		 * value of <code>firstHorizontalGap</code> is <code>NaN</code>, the
		 * value of the <code>horizontalGap</code> property will be used
		 * instead.
		 *
		 * @default NaN
		 *
		 * @see #gap
		 */
		public function get firstHorizontalGap():Number
		{
			return this._firstHorizontalGap;
		}

		/**
		 * @private
		 */
		public function set firstHorizontalGap(value:Number):void
		{
			if(this._firstHorizontalGap == value)
			{
				return;
			}
			this._firstHorizontalGap = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _lastHorizontalGap:Number = NaN;

		/**
		 * The space, in pixels, between the last and second to last items. If
		 * the value of <code>lastHorizontalGap</code> is <code>NaN</code>, the
		 * value of the <code>horizontalGap</code> property will be used instead.
		 *
		 * @default NaN
		 * 
		 * @see #gap
		 */
		public function get lastHorizontalGap():Number
		{
			return this._lastHorizontalGap;
		}

		/**
		 * @private
		 */
		public function set lastHorizontalGap(value:Number):void
		{
			if(this._lastHorizontalGap == value)
			{
				return;
			}
			this._lastHorizontalGap = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * Quickly sets all padding properties to the same value. The
		 * <code>padding</code> getter always returns the value of
		 * <code>paddingTop</code>, but the other padding values may be
		 * different.
		 *
		 * @default 0
		 *
		 * @see #paddingTop
		 * @see #paddingRight
		 * @see #paddingBottom
		 * @see #paddingLeft
		 */
		public function get padding():Number
		{
			return this._paddingTop;
		}

		/**
		 * @private
		 */
		public function set padding(value:Number):void
		{
			this.paddingTop = value;
			this.paddingRight = value;
			this.paddingBottom = value;
			this.paddingLeft = value;
		}

		/**
		 * @private
		 */
		protected var _paddingTop:Number = 0;

		/**
		 * The space, in pixels, above of items.
		 *
		 * @default 0
		 */
		public function get paddingTop():Number
		{
			return this._paddingTop;
		}

		/**
		 * @private
		 */
		public function set paddingTop(value:Number):void
		{
			if(this._paddingTop == value)
			{
				return;
			}
			this._paddingTop = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _paddingRight:Number = 0;

		/**
		 * The space, in pixels, to the right of the items.
		 *
		 * @default 0
		 */
		public function get paddingRight():Number
		{
			return this._paddingRight;
		}

		/**
		 * @private
		 */
		public function set paddingRight(value:Number):void
		{
			if(this._paddingRight == value)
			{
				return;
			}
			this._paddingRight = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _paddingBottom:Number = 0;

		/**
		 * The space, in pixels, below the items.
		 *
		 * @default 0
		 */
		public function get paddingBottom():Number
		{
			return this._paddingBottom;
		}

		/**
		 * @private
		 */
		public function set paddingBottom(value:Number):void
		{
			if(this._paddingBottom == value)
			{
				return;
			}
			this._paddingBottom = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _paddingLeft:Number = 0;

		/**
		 * The space, in pixels, to the left of the items.
		 *
		 * @default 0
		 */
		public function get paddingLeft():Number
		{
			return this._paddingLeft;
		}

		/**
		 * @private
		 */
		public function set paddingLeft(value:Number):void
		{
			if(this._paddingLeft == value)
			{
				return;
			}
			this._paddingLeft = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _horizontalAlign:String = HorizontalAlign.LEFT;

		[Inspectable(type=""String"",enumeration=""left,center,right"")]
		/**
		 * If the total row width is less than the bounds, the items in the row
		 * can be aligned horizontally.
		 * 
		 * <p><strong>Note:</strong> The <code>HorizontalAlign.JUSTIFY</code>
		 * constant is not supported.</p>
		 *
		 * @default feathers.layout.HorizontalAlign.LEFT
		 *
		 * @see feathers.layout.HorizontalAlign#LEFT
		 * @see feathers.layout.HorizontalAlign#CENTER
		 * @see feathers.layout.HorizontalAlign#RIGHT
		 * @see #verticalAlign
		 * @see #rowVerticalAlign
		 */
		public function get horizontalAlign():String
		{
			return this._horizontalAlign;
		}

		/**
		 * @private
		 */
		public function set horizontalAlign(value:String):void
		{
			if(this._horizontalAlign == value)
			{
				return;
			}
			this._horizontalAlign = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _verticalAlign:String = VerticalAlign.TOP;

		[Inspectable(type=""String"",enumeration=""top,middle,bottom"")]
		/**
		 * If the total height of the content is less than the bounds, the
		 * content may be aligned vertically.
		 * 
		 * <p><strong>Note:</strong> The <code>VerticalAlign.JUSTIFY</code>
		 * constant is not supported.</p>
		 *
		 * @default feathers.layout.VerticalAlign.TOP
		 *
		 * @see feathers.layout.VerticalAlign#TOP
		 * @see feathers.layout.VerticalAlign#MIDDLE
		 * @see feathers.layout.VerticalAlign#BOTTOM
		 * @see #horizontalAlign
		 * @see #rowVerticalAlign
		 */
		public function get verticalAlign():String
		{
			return this._verticalAlign;
		}

		/**
		 * @private
		 */
		public function set verticalAlign(value:String):void
		{
			if(this._verticalAlign == value)
			{
				return;
			}
			this._verticalAlign = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _rowVerticalAlign:String = VerticalAlign.TOP;

		[Inspectable(type=""String"",enumeration=""top,middle,bottom"")]
		/**
		 * If the height of an item is less than the height of a row, it can be
		 * aligned vertically.
		 *
		 * @default feathers.layout.VerticalAlign.TOP
		 *
		 * @see feathers.layout.VerticalAlign#TOP
		 * @see feathers.layout.VerticalAlign#MIDDLE
		 * @see feathers.layout.VerticalAlign#BOTTOM
		 * @see #horizontalAlign
		 * @see #verticalAlign
		 */
		public function get rowVerticalAlign():String
		{
			return this._rowVerticalAlign;
		}

		/**
		 * @private
		 */
		public function set rowVerticalAlign(value:String):void
		{
			if(this._rowVerticalAlign == value)
			{
				return;
			}
			this._rowVerticalAlign = value;
			this.dispatchEventWith(Event.CHANGE);
		}

		/**
		 * @private
		 */
		protected var _widthCache:Array = [];

		/**
		 * @private
		 */
		protected var _heightCache:Array = [];

		/**
		 * @inheritDoc
		 */
		public function layout(items:Vector.<DisplayObject>, viewPortBounds:ViewPortBounds = null, result:LayoutBoundsResult = null):LayoutBoundsResult
		{
			//this function is very long because it may be called every frame,
			//in some situations. testing revealed that splitting this function
			//into separate, smaller functions affected performance.
			//since the SWC compiler cannot inline functions, we can't use that
			//feature either.

			//since viewPortBounds can be null, we may need to provide some defaults
			var boundsX:Number = viewPortBounds ? viewPortBounds.x : 0;
			var boundsY:Number = viewPortBounds ? viewPortBounds.y : 0;
			var minWidth:Number = viewPortBounds ? viewPortBounds.minWidth : 0;
			var minHeight:Number = viewPortBounds ? viewPortBounds.minHeight : 0;
			var maxWidth:Number = viewPortBounds ? viewPortBounds.maxWidth : Number.POSITIVE_INFINITY;
			var maxHeight:Number = viewPortBounds ? viewPortBounds.maxHeight : Number.POSITIVE_INFINITY;
			var explicitWidth:Number = viewPortBounds ? viewPortBounds.explicitWidth : NaN;
			var explicitHeight:Number = viewPortBounds ? viewPortBounds.explicitHeight : NaN;
			
			var needsWidth:Boolean = explicitWidth !== explicitWidth; //isNaN
			//let's figure out if we can show multiple rows
			var supportsMultipleRows:Boolean = true;
			var availableRowWidth:Number = explicitWidth;
			if(needsWidth)
			{
				availableRowWidth = maxWidth;
				if(availableRowWidth == Number.POSITIVE_INFINITY)
				{
					supportsMultipleRows = false;
				}
			}

			if(this._useVirtualLayout)
			{
				//if the layout is virtualized, we'll need the dimensions of the
				//typical item so that we have fallback values when an item is null
				if(this._typicalItem is IValidating)
				{
					IValidating(this._typicalItem).validate();
				}
				var calculatedTypicalItemWidth:Number = this._typicalItem ? this._typicalItem.width : 0;
				var calculatedTypicalItemHeight:Number = this._typicalItem ? this._typicalItem.height : 0;
			}

			var i:int = 0;
			var itemCount:int = items.length;
			var positionY:Number = boundsY + this._paddingTop;
			var maxRowWidth:Number = 0;
			var maxItemHeight:Number = 0;
			var verticalGap:Number = this._verticalGap;
			var hasFirstHorizontalGap:Boolean = this._firstHorizontalGap === this._firstHorizontalGap; //!isNaN
			var hasLastHorizontalGap:Boolean = this._lastHorizontalGap === this._lastHorizontalGap; //!isNaN
			var secondToLastIndex:int = itemCount - 2;
			do
			{
				if(i > 0)
				{
					positionY += maxItemHeight + verticalGap;
				}
				//this section prepares some variables needed for the following loop
				maxItemHeight = this._useVirtualLayout ? calculatedTypicalItemHeight : 0;
				var positionX:Number = boundsX + this._paddingLeft;
				//we save the items in this row to align them later.
				this._rowItems.length = 0;
				var rowItemCount:int = 0;

				//if there are no items in the row (such as when there are no
				//items in the container!), then we don't want to subtract the
				//gap when calculating the row width, so default to 0.
				var horizontalGap:Number = 0;

				//this first loop sets the x position of items, and it calculates
				//the total width of all items
				for(; i < itemCount; i++)
				{
					var item:DisplayObject = items[i];
					horizontalGap = this._horizontalGap;
					if(hasFirstHorizontalGap && i == 0)
					{
						horizontalGap = this._firstHorizontalGap;
					}
					else if(hasLastHorizontalGap && i > 0 && i == secondToLastIndex)
					{
						horizontalGap = this._lastHorizontalGap;
					}

					if(this._useVirtualLayout && this._hasVariableItemDimensions)
					{
						var cachedWidth:Number = this._widthCache[i];
						var cachedHeight:Number = this._heightCache[i];
					}
					if(this._useVirtualLayout && !item)
					{
						//the item is null, and the layout is virtualized, so we
						//need to estimate the width of the item.

						if(this._hasVariableItemDimensions)
						{
							if(cachedWidth !== cachedWidth) //isNaN
							{
								var itemWidth:Number = calculatedTypicalItemWidth;
							}
							else
							{
								itemWidth = cachedWidth;
							}
							if(cachedHeight !== cachedHeight) //isNaN
							{
								var itemHeight:Number = calculatedTypicalItemHeight;
							}
							else
							{
								itemHeight = cachedHeight;
							}
						}
						else
						{
							itemWidth = calculatedTypicalItemWidth;
							itemHeight = calculatedTypicalItemHeight;
						}
					}
					else
					{
						//we get here if the item isn't null. it is never null if
						//the layout isn't virtualized.
						if(item is ILayoutDisplayObject && !ILayoutDisplayObject(item).includeInLayout)
						{
							continue;
						}
						if(item is IValidating)
						{
							IValidating(item).validate();
						}
						itemWidth = item.width;
						itemHeight = item.height;
						if(this._useVirtualLayout)
						{
							if(this._hasVariableItemDimensions)
							{
								if(itemWidth != cachedWidth)
								{
									//update the cache if needed. this will notify
									//the container that the virtualized layout has
									//changed, and it the view port may need to be
									//re-measured.
									this._widthCache[i] = itemWidth;
									this.dispatchEventWith(Event.CHANGE);
								}
								if(itemHeight != cachedHeight)
								{
									this._heightCache[i] = itemHeight;
									this.dispatchEventWith(Event.CHANGE);
								}
							}
							else
							{
								if(calculatedTypicalItemWidth >= 0)
								{
									item.width = itemWidth = calculatedTypicalItemWidth;
								}
								if(calculatedTypicalItemHeight >= 0)
								{
									item.height = itemHeight = calculatedTypicalItemHeight;
								}
							}
						}
					}
					if(supportsMultipleRows && rowItemCount > 0 && (positionX + itemWidth) > (availableRowWidth - this._paddingRight))
					{
						//we need to restore the previous gap because it will be
						//subtracted from the x position to get the row width.
						var previousIndex:int = i - 1;
						horizontalGap = this._horizontalGap;
						if(hasFirstHorizontalGap && previousIndex == 0)
						{
							horizontalGap = this._firstHorizontalGap;
						}
						else if(hasLastHorizontalGap && previousIndex > 0 && previousIndex == secondToLastIndex)
						{
							horizontalGap = this._lastHorizontalGap;
						}
						//we've reached the end of the row, so go to next
						break;
					}
					if(item)
					{
						this._rowItems[this._rowItems.length] = item;
						item.x = item.pivotX + positionX;
					}
					positionX += itemWidth + horizontalGap;
					//we compare with > instead of Math.max() because the rest
					//arguments on Math.max() cause extra garbage collection and
					//hurt performance
					if(itemHeight > maxItemHeight)
					{
						//we need to know the maximum height of the items in the
						//case where the height of the view port needs to be
						//calculated by the layout.
						maxItemHeight = itemHeight;
					}
					rowItemCount++;
				}

				//this is the total width of all items in the row
				var totalRowWidth:Number = positionX - horizontalGap + this._paddingRight - boundsX;
				if(totalRowWidth > maxRowWidth)
				{
					maxRowWidth = totalRowWidth;
				}
				rowItemCount = this._rowItems.length;

				if(supportsMultipleRows)
				{
					//in this section, we handle horizontal alignment for the
					//current row. however, we may need to adjust it later if
					//the maxRowWidth is smaller than the availableRowWidth.
					var horizontalAlignOffsetX:Number = 0;
					if(this._horizontalAlign === HorizontalAlign.RIGHT)
					{
						horizontalAlignOffsetX = availableRowWidth - totalRowWidth;
					}
					else if(this._horizontalAlign === HorizontalAlign.CENTER)
					{
						horizontalAlignOffsetX = Math.round((availableRowWidth - totalRowWidth) / 2);
					}
					if(horizontalAlignOffsetX != 0)
					{
						for(var j:int = 0; j < rowItemCount; j++)
						{
							item = this._rowItems[j];
							if(item is ILayoutDisplayObject && !ILayoutDisplayObject(item).includeInLayout)
							{
								continue;
							}
							item.x += horizontalAlignOffsetX;
						}
					}
				}

				for(j = 0; j < rowItemCount; j++)
				{
					item = this._rowItems[j];
					var layoutItem:ILayoutDisplayObject = item as ILayoutDisplayObject;
					if(layoutItem && !layoutItem.includeInLayout)
					{
						continue;
					}
					//handle all other vertical alignment values. the y position
					//of all items is set here.
					switch(this._rowVerticalAlign)
					{
						case VerticalAlign.BOTTOM:
						{
							item.y = item.pivotY + positionY + maxItemHeight - item.height;
							break;
						}
						case VerticalAlign.MIDDLE:
						{
							//round to the nearest pixel when dividing by 2 to
							//align in the middle
							item.y = item.pivotY + positionY + Math.round((maxItemHeight - item.height) / 2);
							break;
						}
						default: //top
						{
							item.y = item.pivotY + positionY;
						}
					}
				}
			}
			while(i < itemCount)
			//we don't want to keep a reference to any of the items, so clear
			//this cache
			this._rowItems.length = 0;

			if(supportsMultipleRows && (needsWidth || explicitWidth < maxRowWidth))
			{
				//if the maxRowWidth has changed since any row was aligned, the
				//items in those rows may need to be shifted a bit
				var contentRowWidth:Number = maxRowWidth;
				if(contentRowWidth < minWidth)
				{
					contentRowWidth = minWidth;
				}
				else if(contentRowWidth > maxWidth)
				{
					contentRowWidth = maxWidth;
				}
				horizontalAlignOffsetX = 0;
				if(this._horizontalAlign === HorizontalAlign.RIGHT)
				{
					horizontalAlignOffsetX = availableRowWidth - contentRowWidth;
				}
				else if(this._horizontalAlign === HorizontalAlign.CENTER)
				{
					horizontalAlignOffsetX = Math.round((availableRowWidth - contentRowWidth) / 2);
				}
				if(horizontalAlignOffsetX != 0)
				{
					for(i = 0; i < itemCount; i++)
					{
						item = items[i];
						if(!item || (item is ILayoutDisplayObject && !ILayoutDisplayObject(item).includeInLayout))
						{
							continue;
						}
						//previously, we used the maxWidth for alignment,
						//but the max row width may be smaller, so we need
						//to account for the difference
						item.x -= horizontalAlignOffsetX;
					}
				}
			}
			else
			{
				contentRowWidth = maxRowWidth;
			}
			if(needsWidth)
			{
				availableRowWidth = contentRowWidth;
			}

			var totalHeight:Number = positionY + maxItemHeight + this._paddingBottom;
			//the available height is the height of the viewport. if the explicit
			//height is NaN, we need to calculate the viewport height ourselves
			//based on the total height of all items.
			var availableHeight:Number = explicitHeight;
			if(availableHeight !== availableHeight) //isNaN
			{
				availableHeight = totalHeight;
				if(availableHeight < minHeight)
				{
					availableHeight = minHeight;
				}
				else if(availableHeight > maxHeight)
				{
					availableHeight = maxHeight;
				}
			}

			if(totalHeight < availableHeight &&
				this._verticalAlign != VerticalAlign.TOP)
			{
				var verticalAlignOffset:Number = availableHeight - totalHeight;
				if(this._verticalAlign === VerticalAlign.MIDDLE)
				{
					verticalAlignOffset /= 2;
				}
				for(i = 0; i < itemCount; i++)
				{
					item = items[i];
					if(!item || (item is ILayoutDisplayObject && !ILayoutDisplayObject(item).includeInLayout))
					{
						continue;
					}
					item.y += verticalAlignOffset;
				}
			}

			//finally, we want to calculate the result so that the container
			//can use it to adjust its viewport and determine the minimum and
			//maximum scroll positions (if needed)
			if(!result)
			{
				result = new LayoutBoundsResult();
			}
			result.contentX = 0;
			result.contentWidth = maxRowWidth;
			result.contentY = 0;
			result.contentHeight = totalHeight;
			result.viewPortWidth = availableRowWidth;
			result.viewPortHeight = availableHeight;
			return result;
		}

		/**
		 * @inheritDoc
		 */
		public function measureViewPort(itemCount:int, viewPortBounds:ViewPortBounds = null, result:Point = null):Point
		{
			if(!result)
			{
				result = new Point();
			}
			if(!this._useVirtualLayout)
			{
				throw new IllegalOperationError(""measureViewPort() may be called only if useVirtualLayout is true."")
			}
			//this function is very long because it may be called every frame,
			//in some situations. testing revealed that splitting this function
			//into separate, smaller functions affected performance.
			//since the SWC compiler cannot inline functions, we can't use that
			//feature either.

			//since viewPortBounds can be null, we may need to provide some defaults
			var boundsX:Number = viewPortBounds ? viewPortBounds.x : 0;
			var boundsY:Number = viewPortBounds ? viewPortBounds.y : 0;
			var minWidth:Number = viewPortBounds ? viewPortBounds.minWidth : 0;
			var minHeight:Number = viewPortBounds ? viewPortBounds.minHeight : 0;
			var maxWidth:Number = viewPortBounds ? viewPortBounds.maxWidth : Number.POSITIVE_INFINITY;
			var maxHeight:Number = viewPortBounds ? viewPortBounds.maxHeight : Number.POSITIVE_INFINITY;
			var explicitWidth:Number = viewPortBounds ? viewPortBounds.explicitWidth : NaN;
			var explicitHeight:Number = viewPortBounds ? viewPortBounds.explicitHeight : NaN;

			//let's figure out if we can show multiple rows
			var supportsMultipleRows:Boolean = true;
			var availableRowWidth:Number = explicitWidth;
			if(availableRowWidth !== availableRowWidth) //isNaN
			{
				availableRowWidth = maxWidth;
				if(availableRowWidth == Number.POSITIVE_INFINITY)
				{
					supportsMultipleRows = false;
				}
			}
			
			if(this._typicalItem is IValidating)
			{
				IValidating(this._typicalItem).validate();
			}
			var calculatedTypicalItemWidth:Number = this._typicalItem ? this._typicalItem.width : 0;
			var calculatedTypicalItemHeight:Number = this._typicalItem ? this._typicalItem.height : 0;

			var i:int = 0;
			var positionY:Number = boundsY + this._paddingTop;
			var maxRowWidth:Number = 0;
			var maxItemHeight:Number = 0;
			var verticalGap:Number = this._verticalGap;
			var hasFirstHorizontalGap:Boolean = this._firstHorizontalGap === this._firstHorizontalGap; //!isNaN
			var hasLastHorizontalGap:Boolean = this._lastHorizontalGap === this._lastHorizontalGap; //!isNaN
			var secondToLastIndex:int = itemCount - 2;
			do
			{
				if(i > 0)
				{
					positionY += maxItemHeight + verticalGap;
				}
				//this section prepares some variables needed for the following loop
				maxItemHeight = this._useVirtualLayout ? calculatedTypicalItemHeight : 0;
				var positionX:Number = boundsX + this._paddingLeft;
				var rowItemCount:int = 0;

				//if there are no items in the row (such as when there are no
				//items in the container!), then we don't want to subtract the
				//gap when calculating the row width, so default to 0.
				var horizontalGap:Number = 0;

				//this first loop sets the x position of items, and it calculates
				//the total width of all items
				for(; i < itemCount; i++)
				{
					horizontalGap = this._horizontalGap;
					if(hasFirstHorizontalGap && i == 0)
					{
						horizontalGap = this._firstHorizontalGap;
					}
					else if(hasLastHorizontalGap && i > 0 && i == secondToLastIndex)
					{
						horizontalGap = this._lastHorizontalGap;
					}
					if(this._hasVariableItemDimensions)
					{
						var cachedWidth:Number = this._widthCache[i];
						var cachedHeight:Number = this._heightCache[i];
						if(cachedWidth !== cachedWidth) //isNaN
						{
							var itemWidth:Number = calculatedTypicalItemWidth;
						}
						else
						{
							itemWidth = cachedWidth;
						}
						if(cachedHeight !== cachedHeight) //isNaN
						{
							var itemHeight:Number = calculatedTypicalItemHeight;
						}
						else
						{
							itemHeight = cachedHeight;
						}
					}
					else
					{
						itemWidth = calculatedTypicalItemWidth;
						itemHeight = calculatedTypicalItemHeight;
					}
					if(supportsMultipleRows && rowItemCount > 0 && (positionX + itemWidth) > (availableRowWidth - this._paddingRight))
					{
						//we've reached the end of the row, so go to next
						break;
					}
					positionX += itemWidth + horizontalGap;
					//we compare with > instead of Math.max() because the rest
					//arguments on Math.max() cause extra garbage collection and
					//hurt performance
					if(itemHeight > maxItemHeight)
					{
						//we need to know the maximum height of the items in the
						//case where the height of the view port needs to be
						//calculated by the layout.
						maxItemHeight = itemHeight;
					}
					rowItemCount++;
				}

				//this is the total width of all items in the row
				var totalRowWidth:Number = positionX - horizontalGap + this._paddingRight - boundsX;
				if(totalRowWidth > maxRowWidth)
				{
					maxRowWidth = totalRowWidth;
				}
			}
			while(i < itemCount)

			if(supportsMultipleRows)
			{
				if(explicitWidth !== explicitWidth) //isNaN
				{
					availableRowWidth = maxRowWidth;
					if(availableRowWidth < minWidth)
					{
						availableRowWidth = minWidth;
					}
					else if(availableRowWidth > maxWidth)
					{
						availableRowWidth = maxWidth;
					}
				}
			}
			else
			{
				availableRowWidth = maxRowWidth;
			}
			
			var totalHeight:Number = positionY + maxItemHeight + this._paddingBottom;
			//the available height is the height of the viewport. if the explicit
			//height is NaN, we need to calculate the viewport height ourselves
			//based on the total height of all items.
			var availableHeight:Number = explicitHeight;
			if(availableHeight !== availableHeight) //isNaN
			{
				availableHeight = totalHeight;
				if(availableHeight < minHeight)
				{
					availableHeight = minHeight;
				}
				else if(availableHeight > maxHeight)
				{
					availableHeight = maxHeight;
				}
			}

			result.x = availableRowWidth;
			result.y = availableHeight;
			return result;
		}

		/**
		 * @inheritDoc
		 */
		public function getNearestScrollPositionForIndex(index:int, scrollX:Number, scrollY:Number, items:Vector.<DisplayObject>,
			x:Number, y:Number, width:Number, height:Number, result:Point = null):Point
		{
			result = this.calculateMaxScrollYAndRowHeightOfIndex(index, items, x, y, width, height, result);
			var maxScrollY:Number = result.x;
			var rowHeight:Number = result.y;
			
			result.x = 0;
			
			var bottomPosition:Number = maxScrollY - (height - rowHeight);
			if(scrollY >= bottomPosition && scrollY <= maxScrollY)
			{
				//keep the current scroll position because the item is already
				//fully visible
				result.y = scrollY;
			}
			else
			{
				var topDifference:Number = Math.abs(maxScrollY - scrollY);
				var bottomDifference:Number = Math.abs(bottomPosition - scrollY);
				if(bottomDifference < topDifference)
				{
					result.y = bottomPosition;
				}
				else
				{
					result.y = maxScrollY;
				}
			}

			return result;
		}

		/**
		 * @inheritDoc
		 */
		public function calculateNavigationDestination(items:Vector.<DisplayObject>, index:int, keyCode:uint, bounds:LayoutBoundsResult):int
		{
			var result:int = index;
			if(keyCode == Keyboard.HOME)
			{
				if(items.length > 0)
				{
					result = 0;
				}
			}
			else if(keyCode == Keyboard.END)
			{
				result = items.length - 1;
			}
			else if(keyCode == Keyboard.UP)
			{
				result--;
			}
			else if(keyCode == Keyboard.DOWN)
			{
				result++;
			}
			if(result < 0)
			{
				return 0;
			}
			if(result >= items.length)
			{
				return items.length - 1;
			}
			return result;
		}

		/**
		 * @inheritDoc
		 */
		public function getScrollPositionForIndex(index:int, items:Vector.<DisplayObject>, x:Number, y:Number, width:Number, height:Number, result:Point = null):Point
		{
			result = this.calculateMaxScrollYAndRowHeightOfIndex(index, items, x, y, width, height, result);
			var maxScrollY:Number = result.x;
			var rowHeight:Number = result.y;

			if(this._useVirtualLayout)
			{
				if(this._hasVariableItemDimensions)
				{
					var itemHeight:Number = this._heightCache[index];
					if(itemHeight !== itemHeight) //isNaN
					{
						itemHeight = this._typicalItem.height;
					}
				}
				else
				{
					itemHeight = this._typicalItem.height;
				}
			}
			else
			{
				itemHeight = items[index].height;
			}

			if(!result)
			{
				result = new Point();
			}
			result.x = 0;
			result.y = maxScrollY - Math.round((height - itemHeight) / 2);

			return result;
		}

		/**
		 * @inheritDoc
		 */
		public function getDropIndex(x:Number, y:Number, items:Vector.<DisplayObject>,
			boundsX:Number, boundsY:Number, width:Number, height:Number):int
		{
			if(this._useVirtualLayout)
			{
				//if the layout is virtualized, we'll need the dimensions of the
				//typical item so that we have fallback values when an item is null
				if(this._typicalItem is IValidating)
				{
					IValidating(this._typicalItem).validate();
				}
				var calculatedTypicalItemWidth:Number = this._typicalItem ? this._typicalItem.width : 0;
				var calculatedTypicalItemHeight:Number = this._typicalItem ? this._typicalItem.height : 0;
			}

			var horizontalGap:Number = this._horizontalGap;
			var verticalGap:Number = this._verticalGap;
			var maxItemHeight:Number = 0;
			var positionY:Number = this._paddingTop;
			var i:int = 0;
			var itemCount:int = items.length;
			do
			{
				if(i > 0)
				{
					positionY += maxItemHeight + verticalGap;
				}
				//this section prepares some variables needed for the following loop
				maxItemHeight = this._useVirtualLayout ? calculatedTypicalItemHeight : 0;
				var positionX:Number = this._paddingLeft;
				var rowItemCount:int = 0;
				for(; i < itemCount; i++)
				{
					var item:DisplayObject = items[i];

					if(this._useVirtualLayout && this._hasVariableItemDimensions)
					{
						var cachedWidth:Number = this._widthCache[i];
						var cachedHeight:Number = this._heightCache[i];
					}
					if(this._useVirtualLayout && !item)
					{
						//the item is null, and the layout is virtualized, so we
						//need to estimate the width of the item.

						if(this._hasVariableItemDimensions)
						{
							if(cachedWidth !== cachedWidth) //isNaN
							{
								var itemWidth:Number = calculatedTypicalItemWidth;
							}
							else
							{
								itemWidth = cachedWidth;
							}
							if(cachedHeight !== cachedHeight) //isNaN
							{
								var itemHeight:Number = calculatedTypicalItemHeight;
							}
							else
							{
								itemHeight = cachedHeight;
							}
						}
						else
						{
							itemWidth = calculatedTypicalItemWidth;
							itemHeight = calculatedTypicalItemHeight;
						}
					}
					else
					{
						//we get here if the item isn't null. it is never null if
						//the layout isn't virtualized.
						if(item is ILayoutDisplayObject && !ILayoutDisplayObject(item).includeInLayout)
						{
							continue;
						}
						if(item is IValidating)
						{
							IValidating(item).validate();
						}
						itemWidth = item.width;
						itemHeight = item.height;
						if(this._useVirtualLayout && this._hasVariableItemDimensions)
						{
							if(this._hasVariableItemDimensions)
							{
								if(itemWidth != cachedWidth)
								{
									this._widthCache[i] = itemWidth;
									this.dispatchEventWith(Event.CHANGE);
								}
								if(itemHeight != cachedHeight)
								{
									this._heightCache[i] = itemHeight;
									this.dispatchEventWith(Event.CHANGE);
								}
							}
							else
							{
								if(calculatedTypicalItemWidth >= 0)
								{
									itemWidth = calculatedTypicalItemWidth;
								}
								if(calculatedTypicalItemHeight >= 0)
								{
									itemHeight = calculatedTypicalItemHeight;
								}
							}
						}
					}
					var endOfRow:Boolean = rowItemCount > 0 && (positionX + itemWidth) > (width - this._paddingRight);
					if((endOfRow || x < (positionX + (itemWidth / 2))) && y < (positionY + itemHeight + (gap / 2)))
					{
						return i;
					}
					if(endOfRow)
					{
						//we've reached the end of the row, so go to next
						break;
					}
					//we compare with > instead of Math.max() because the rest
					//arguments on Math.max() cause extra garbage collection and
					//hurt performance
					if(itemHeight > maxItemHeight)
					{
						//we need to know the maximum height of the items in the
						//case where the height of the view port needs to be
						//calculated by the layout.
						maxItemHeight = itemHeight;
					}
					positionX += itemWidth + horizontalGap;
					rowItemCount++;
				}
			}
			while(i < itemCount)
			return itemCount;
		}

		/**
		 * @inheritDoc
		 */
		public function positionDropIndicator(dropIndicator:DisplayObject, index:int,
			x:Number, y: Number, items:Vector.<DisplayObject>, width:Number, height:Number):void
		{
			if(dropIndicator is IValidating)
			{
				IValidating(dropIndicator).validate();
			}

			var horizontalGap:Number = this._horizontalGap;
			var verticalGap:Number = this._verticalGap;
			var maxItemHeight:Number = 0;
			var positionY:Number = this._paddingTop;
			var i:int = 0;
			var itemCount:int = items.length;
			do
			{
				if(i > 0)
				{
					if(y < (positionY + itemHeight + (verticalGap / 2)))
					{
						//if the x/y position is closer to the previous row,
						//then display the drop indicator at the end of that row
						var item:DisplayObject = items[i - 1];
						dropIndicator.x = item.x + item.width - dropIndicator.width / 2;
						dropIndicator.y = item.y;
						dropIndicator.height = item.height;
						return;
					}
					positionY += maxItemHeight + verticalGap;
				}
				//this section prepares some variables needed for the following loop
				maxItemHeight = 0;
				var positionX:Number = this._paddingLeft;
				var rowItemCount:int = 0;
				for(; i < itemCount; i++)
				{
					item = items[i];
					var itemWidth:Number = item.width;
					var itemHeight:Number = item.height;
					if(rowItemCount > 0 && (positionX + itemWidth) > (width - this._paddingRight))
					{
						//we've reached the end of the row, so go to next
						break;
					}
					//we compare with > instead of Math.max() because the rest
					//arguments on Math.max() cause extra garbage collection and
					//hurt performance
					if(itemHeight > maxItemHeight)
					{
						//we need to know the maximum height of the items in the
						//case where the height of the view port needs to be
						//calculated by the layout.
						maxItemHeight = itemHeight;
					}
					if(i == index)
					{
						dropIndicator.x = item.x - dropIndicator.width / 2;
						dropIndicator.y = item.y;
						dropIndicator.height = item.height;
						return;
					}
					positionX += itemWidth + horizontalGap;
					rowItemCount++;
				}
			}
			while(i < itemCount)
			var lastItem:DisplayObject = items[itemCount - 1];
			dropIndicator.x = lastItem.x + lastItem.width - dropIndicator.width / 2;
			dropIndicator.y = lastItem.y;
			dropIndicator.height = lastItem.height;
		}

		/**
		 * @inheritDoc
		 */
		override public function resetVariableVirtualCache():void
		{
			this._widthCache.length = 0;
			this._heightCache.length = 0;
		}

		/**
		 * @inheritDoc
		 */
		override public function resetVariableVirtualCacheAtIndex(index:int, item:DisplayObject = null):void
		{
			delete this._widthCache[index];
			delete this._heightCache[index];
			if(item)
			{
				this._widthCache[index] = item.width;
				this._heightCache[index] = item.height;
				this.dispatchEventWith(Event.CHANGE);
			}
		}

		/**
		 * @inheritDoc
		 */
		override public function addToVariableVirtualCacheAtIndex(index:int, item:DisplayObject = null):void
		{
			var widthValue:* = (item !== null) ? item.width : undefined;
			var heightValue:* = (item !== null) ? item.height : undefined;
			this._widthCache.insertAt(index, widthValue);
			this._heightCache.insertAt(index, heightValue);
		}

		/**
		 * @inheritDoc
		 */
		override public function removeFromVariableVirtualCacheAtIndex(index:int):void
		{
			this._widthCache.removeAt(index);
			this._heightCache.removeAt(index);
		}

		/**
		 * @inheritDoc
		 */
		public function getVisibleIndicesAtScrollPosition(scrollX:Number, scrollY:Number, width:Number, height:Number, itemCount:int, result:Vector.<int> = null):Vector.<int>
		{
			if(result)
			{
				result.length = 0;
			}
			else
			{
				result = new <int>[];
			}
			if(!this._useVirtualLayout)
			{
				throw new IllegalOperationError(""getVisibleIndicesAtScrollPosition() may be called only if useVirtualLayout is true."")
			}

			if(this._typicalItem is IValidating)
			{
				IValidating(this._typicalItem).validate();
			}
			var calculatedTypicalItemWidth:Number = this._typicalItem ? this._typicalItem.width : 0;
			var calculatedTypicalItemHeight:Number = this._typicalItem ? this._typicalItem.height : 0;

			var resultLastIndex:int = 0;

			var i:int = 0;
			var positionY:Number = this._paddingTop;
			var maxItemHeight:Number = 0;
			var verticalGap:Number = this._verticalGap;
			var maxPositionY:Number = scrollY + height;
			var hasFirstHorizontalGap:Boolean = this._firstHorizontalGap === this._firstHorizontalGap; //!isNaN
			var hasLastHorizontalGap:Boolean = this._lastHorizontalGap === this._lastHorizontalGap; //!isNaN
			var secondToLastIndex:int = itemCount - 2;
			do
			{
				if(i > 0)
				{
					positionY += maxItemHeight + verticalGap;
					if(positionY >= maxPositionY)
					{
						//the following rows will not be visible, so we can stop
						break;
					}
				}
				//this section prepares some variables needed for the following loop
				maxItemHeight = calculatedTypicalItemHeight;
				var positionX:Number = this._paddingLeft;
				var rowItemCount:int = 0;

				//this first loop sets the x position of items, and it calculates
				//the total width of all items
				for(; i < itemCount; i++)
				{
					var horizontalGap:Number = this._horizontalGap;
					if(hasFirstHorizontalGap && i == 0)
					{
						horizontalGap = this._firstHorizontalGap;
					}
					else if(hasLastHorizontalGap && i > 0 && i == secondToLastIndex)
					{
						horizontalGap = this._lastHorizontalGap;
					}
					if(this._hasVariableItemDimensions)
					{
						var cachedWidth:Number = this._widthCache[i];
						var cachedHeight:Number = this._heightCache[i];
					}
					if(this._hasVariableItemDimensions)
					{
						if(cachedWidth !== cachedWidth) //isNaN
						{
							var itemWidth:Number = calculatedTypicalItemWidth;
						}
						else
						{
							itemWidth = cachedWidth;
						}
						if(cachedHeight !== cachedHeight) //isNaN
						{
							var itemHeight:Number = calculatedTypicalItemHeight;
						}
						else
						{
							itemHeight = cachedHeight;
						}
					}
					else
					{
						itemWidth = calculatedTypicalItemWidth;
						itemHeight = calculatedTypicalItemHeight;
					}
					if(rowItemCount > 0 && (positionX + itemWidth) > (width - this._paddingRight))
					{
						//we've reached the end of the row, so go to next
						break;
					}
					if((positionY + itemHeight) > scrollY)
					{
						result[resultLastIndex] = i;
						resultLastIndex++;
					}
					positionX += itemWidth + horizontalGap;
					//we compare with > instead of Math.max() because the rest
					//arguments on Math.max() cause extra garbage collection and
					//hurt performance
					if(itemHeight > maxItemHeight)
					{
						//we need to know the maximum height of the items in the
						//case where the height of the view port needs to be
						//calculated by the layout.
						maxItemHeight = itemHeight;
					}
					rowItemCount++;
				}
			}
			while(i < itemCount)
			return result;
		}

		/**
		 * @private
		 */
		protected function calculateMaxScrollYAndRowHeightOfIndex(index:int, items:Vector.<DisplayObject>,
			x:Number, y:Number, width:Number, height:Number, result:Point = null):Point
		{
			if(!result)
			{
				result = new Point();
			}
			if(this._useVirtualLayout)
			{
				//if the layout is virtualized, we'll need the dimensions of the
				//typical item so that we have fallback values when an item is null
				if(this._typicalItem is IValidating)
				{
					IValidating(this._typicalItem).validate();
				}
				var calculatedTypicalItemWidth:Number = this._typicalItem ? this._typicalItem.width : 0;
				var calculatedTypicalItemHeight:Number = this._typicalItem ? this._typicalItem.height : 0;
			}

			var horizontalGap:Number = this._horizontalGap;
			var verticalGap:Number = this._verticalGap;
			var maxItemHeight:Number = 0;
			var positionY:Number = y + this._paddingTop;
			var i:int = 0;
			var itemCount:int = items.length;
			var isLastRow:Boolean = false;
			do
			{
				if(isLastRow)
				{
					break;
				}
				if(i > 0)
				{
					positionY += maxItemHeight + verticalGap;
				}
				//this section prepares some variables needed for the following loop
				maxItemHeight = this._useVirtualLayout ? calculatedTypicalItemHeight : 0;
				var positionX:Number = x + this._paddingLeft;
				var rowItemCount:int = 0;
				for(; i < itemCount; i++)
				{
					var item:DisplayObject = items[i];

					if(this._useVirtualLayout && this._hasVariableItemDimensions)
					{
						var cachedWidth:Number = this._widthCache[i];
						var cachedHeight:Number = this._heightCache[i];
					}
					if(this._useVirtualLayout && !item)
					{
						//the item is null, and the layout is virtualized, so we
						//need to estimate the width of the item.

						if(this._hasVariableItemDimensions)
						{
							if(cachedWidth !== cachedWidth) //isNaN
							{
								var itemWidth:Number = calculatedTypicalItemWidth;
							}
							else
							{
								itemWidth = cachedWidth;
							}
							if(cachedHeight !== cachedHeight) //isNaN
							{
								var itemHeight:Number = calculatedTypicalItemHeight;
							}
							else
							{
								itemHeight = cachedHeight;
							}
						}
						else
						{
							itemWidth = calculatedTypicalItemWidth;
							itemHeight = calculatedTypicalItemHeight;
						}
					}
					else
					{
						//we get here if the item isn't null. it is never null if
						//the layout isn't virtualized.
						if(item is ILayoutDisplayObject && !ILayoutDisplayObject(item).includeInLayout)
						{
							continue;
						}
						if(item is IValidating)
						{
							IValidating(item).validate();
						}
						itemWidth = item.width;
						itemHeight = item.height;
						if(this._useVirtualLayout && this._hasVariableItemDimensions)
						{
							if(this._hasVariableItemDimensions)
							{
								if(itemWidth != cachedWidth)
								{
									this._widthCache[i] = itemWidth;
									this.dispatchEventWith(Event.CHANGE);
								}
								if(itemHeight != cachedHeight)
								{
									this._heightCache[i] = itemHeight;
									this.dispatchEventWith(Event.CHANGE);
								}
							}
							else
							{
								if(calculatedTypicalItemWidth >= 0)
								{
									itemWidth = calculatedTypicalItemWidth;
								}
								if(calculatedTypicalItemHeight >= 0)
								{
									itemHeight = calculatedTypicalItemHeight;
								}
							}
						}
					}
					if(rowItemCount > 0 && (positionX + itemWidth) > (width - this._paddingRight))
					{
						//we've reached the end of the row, so go to next
						break;
					}
					//we don't check this at the beginning of the loop because
					//it may break to start a new row and then redo this item
					if(i == index)
					{
						isLastRow = true;
					}
					//we compare with > instead of Math.max() because the rest
					//arguments on Math.max() cause extra garbage collection and
					//hurt performance
					if(itemHeight > maxItemHeight)
					{
						//we need to know the maximum height of the items in the
						//case where the height of the view port needs to be
						//calculated by the layout.
						maxItemHeight = itemHeight;
					}
					positionX += itemWidth + horizontalGap;
					rowItemCount++;
				}
			}
			while(i < itemCount)
			result.setTo(positionY, maxItemHeight);
			return result;
		}
	}
}
",12313,True,2592.0684858900345,median
"
//Created by Action Script Viewer - http://www.buraks.com/asv
    class mx.video.FLVPlayback extends MovieClip
    {
        var _autoPlay, _autoRewind, _autoSize, _bufferTime, _contentPath, _cuePoints, _idleTimeout, _isLive, _aspectRatio, _seekToPrevOffset, _playheadUpdateInterval, _progressInterval, _totalTime, _transform, _volume, _skinAutoHide, _bufferingBarHides, _origHeight, _prevHeight, __height, _height, _origWidth, _prevWidth, __width, _width, _scaleX, _scaleY, _xscale, _yscale, _preSeekTime, _firstStreamReady, _firstStreamShown, _activeVP, _visibleVP, _topVP, _vp, _vpState, _cpMgr, boundingBox_mc, preview_mc, dispatchEvent, _uiMgr, _bufferingBar, _backButton, __get__cuePoints, _forwardButton, _muteButton, _pauseButton, _playButton, _playPauseButton, _seekBar, _seekBarInterval, _seekBarScrubTolerance, _skin, _stopButton, _visible, _volumeBar, _volumeBarInterval, _volumeBarScrubTolerance, _x, _y, attachMovie, createEmptyMovieClip;
        function FLVPlayback () {
            super();
            mx.events.EventDispatcher.initialize(this);
            if (_autoPlay == undefined) {
                _autoPlay = true;
            }
            if (_autoRewind == undefined) {
                _autoRewind = true;
            }
            if (_autoSize == undefined) {
                _autoSize = false;
            }
            if (_bufferTime == undefined) {
                _bufferTime = 0.1;
            }
            if (_contentPath == undefined) {
                _contentPath = """";
            }
            if (_cuePoints == undefined) {
                _cuePoints = null;
            }
            if (_idleTimeout == undefined) {
                _idleTimeout = mx.video.VideoPlayer.DEFAULT_IDLE_TIMEOUT_INTERVAL;
            }
            if (_isLive == undefined) {
                _isLive = false;
            }
            if (_aspectRatio == undefined) {
                _aspectRatio = true;
            }
            if (_seekToPrevOffset == undefined) {
                _seekToPrevOffset = SEEK_TO_PREV_OFFSET_DEFAULT;
            }
            if (_playheadUpdateInterval == undefined) {
                _playheadUpdateInterval = mx.video.VideoPlayer.DEFAULT_UPDATE_PROGRESS_INTERVAL;
            }
            if (_progressInterval == undefined) {
                _progressInterval = mx.video.VideoPlayer.DEFAULT_UPDATE_TIME_INTERVAL;
            }
            if (_totalTime == undefined) {
                _totalTime = 0;
            }
            if (_transform == undefined) {
                _transform = null;
            }
            if (_volume == undefined) {
                _volume = 100;
            }
            if (_skinAutoHide == undefined) {
                _skinAutoHide = false;
            }
            if (_bufferingBarHides == undefined) {
                _bufferingBarHides = false;
            }
            _origHeight = (_prevHeight = (__height = _height));
            _origWidth = (_prevWidth = (__width = _width));
            _scaleX = 100;
            _scaleY = 100;
            _xscale = 100;
            _yscale = 100;
            _preSeekTime = -1;
            _firstStreamReady = false;
            _firstStreamShown = false;
            createUIManager();
            _activeVP = 0;
            _visibleVP = 0;
            _topVP = 0;
            _vp = new Array();
            _vpState = new Array();
            _cpMgr = new Array();
            createVideoPlayer(0);
            _vp[0].visible = false;
            _vp[0].volume = 0;
            boundingBox_mc._visible = false;
            boundingBox_mc.unloadMovie();
            delete boundingBox_mc;
            if (_global.isLivePreview) {
                createLivePreviewMovieClip();
                setSize(__width, __height);
            }
            _cpMgr[0].processCuePointsProperty(_cuePoints);
            delete _cuePoints;
            _cuePoints = null;
        }
        function setSize(_arg5, _arg4) {
            if (_global.isLivePreview) {
                if (preview_mc == undefined) {
                    createLivePreviewMovieClip();
                }
                preview_mc.box_mc._width = _arg5;
                preview_mc.box_mc._height = _arg4;
                if ((preview_mc.box_mc._width < preview_mc.icon_mc._width) || (preview_mc.box_mc._height < preview_mc.icon_mc._height)) {
                    preview_mc.icon_mc._visible = false;
                } else {
                    preview_mc.icon_mc._visible = true;
                    preview_mc.icon_mc._x = (preview_mc.box_mc._width - preview_mc.icon_mc._width) / 2;
                    preview_mc.icon_mc._y = (preview_mc.box_mc._height - preview_mc.icon_mc._height) / 2;
                }
            }
            if ((_arg5 == width) && (_arg4 == height)) {
                return(undefined);
            }
            _prevWidth = (__width = _arg5);
            _prevHeight = (__height = _arg4);
            var _local3 = 0;
            while (_local3 < _vp.length) {
                if (_vp[_local3] != undefined) {
                    _vp[_local3].setSize(_arg5, _arg4);
                }
                _local3++;
            }
            dispatchEvent({type:""resize"", x:x, y:y, width:_arg5, height:_arg4});
        }
        function setScale(_arg4, _arg3) {
            if ((_arg4 == scaleX) && (_arg3 == scaleY)) {
                return(undefined);
            }
            _scaleX = _arg4;
            _scaleY = _arg3;
            var _local2 = 0;
            while (_local2 < _vp.length) {
                if (_vp[_local2] != undefined) {
                    _vp[_local2].setSize((_origWidth * _arg4) / 100, (_origHeight * _arg3) / 100);
                }
                _local2++;
            }
            dispatchEvent({type:""resize"", x:x, y:y, width:width, height:height});
        }
        function handleEvent(_arg2) {
            var _local3 = _arg2.state;
            if (((_arg2.state != undefined) && (_arg2.target._name == _visibleVP)) && (scrubbing)) {
                _local3 = SEEKING;
            }
            if (_arg2.type == ""metadataReceived"") {
                _cpMgr[_arg2.target._name].processFLVCuePoints(_arg2.info.cuePoints);
                dispatchEvent({type:_arg2.type, info:_arg2.info, vp:_arg2.target._name});
            } else if (_arg2.type == ""cuePoint"") {
                if (_cpMgr[_arg2.target._name].isFLVCuePointEnabled(_arg2.info)) {
                    dispatchEvent({type:_arg2.type, info:_arg2.info, vp:_arg2.target._name});
                }
            } else if (_arg2.type == ""rewind"") {
                dispatchEvent({type:_arg2.type, auto:true, state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                _cpMgr[_arg2.target._name].resetASCuePointIndex(_arg2.playheadTime);
            } else if (_arg2.type == ""resize"") {
                dispatchEvent({type:_arg2.type, x:x, y:y, width:width, height:height, auto:true, vp:_arg2.target._name});
                _prevWidth = __width;
                _prevHeight = __height;
            } else if (_arg2.type == ""playheadUpdate"") {
                dispatchEvent({type:_arg2.type, state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                if ((_preSeekTime >= 0) && (_arg2.target.state != SEEKING)) {
                    var _local5 = _preSeekTime;
                    _preSeekTime = -1;
                    _cpMgr[_arg2.target._name].resetASCuePointIndex(_arg2.playheadTime);
                    dispatchEvent({type:""seek"", state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                    if (_local5 < _arg2.playheadTime) {
                        dispatchEvent({type:""fastForward"", state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                    } else if (_local5 > _arg2.playheadTime) {
                        dispatchEvent({type:""rewind"", auto:false, state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                    }
                }
                _cpMgr[_arg2.target._name].dispatchASCuePoints();
            } else if (_arg2.type == ""stateChange"") {
                var _local4 = _arg2.target._name;
                if ((_local4 == _visibleVP) && (scrubbing)) {
                    return(undefined);
                }
                if (_arg2.state == mx.video.VideoPlayer.RESIZING) {
                    return(undefined);
                }
                if (((_vpState[_local4].prevState == LOADING) && (_vpState[_local4].autoPlay)) && (_arg2.state == STOPPED)) {
                    return(undefined);
                }
                _vpState[_local4].prevState = _arg2.state;
                dispatchEvent({type:_arg2.type, state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                if (_vp[_arg2.target._name].state != _local3) {
                    return(undefined);
                }
                switch (_local3) {
                    case BUFFERING : 
                        dispatchEvent({type:""buffering"", state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                        break;
                    case PAUSED : 
                        dispatchEvent({type:""paused"", state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                        break;
                    case PLAYING : 
                        dispatchEvent({type:""playing"", state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                        break;
                    case STOPPED : 
                        dispatchEvent({type:""stopped"", state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
                        break;
                }
            } else if (_arg2.type == ""progress"") {
                dispatchEvent({type:_arg2.type, bytesLoaded:_arg2.bytesLoaded, bytesTotal:_arg2.bytesTotal, vp:_arg2.target._name});
            } else if (_arg2.type == ""ready"") {
                var _local4 = _arg2.target._name;
                if (!_firstStreamReady) {
                    if (_local4 == _visibleVP) {
                        _firstStreamReady = true;
                        if (_uiMgr.__get__skinReady() && (!_firstStreamShown)) {
                            _uiMgr.__set__visible(true);
                            showFirstStream();
                        }
                    }
                } else if ((_firstStreamShown && (_local3 == STOPPED)) && _vpState[_local4].autoPlay) {
                    _vp[_local4].play();
                }
                dispatchEvent({type:_arg2.type, state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
            } else if ((_arg2.type == ""close"") || (_arg2.type == ""complete"")) {
                dispatchEvent({type:_arg2.type, state:_local3, playheadTime:_arg2.playheadTime, vp:_arg2.target._name});
            }
        }
        function load(_arg2, _arg4, _arg3) {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            if (((_arg2 == undefined) || (_arg2 == null)) || (_arg2 == """")) {
                return(undefined);
            }
            autoPlay = (false);
            if (_arg4 != undefined) {
                totalTime = (_arg4);
            }
            if (_arg3 != undefined) {
                isLive = (_arg3);
            }
            contentPath = (_arg2);
        }
        function play(_arg3, _arg4, _arg2) {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            if (_arg3 == undefined) {
                _vp[_activeVP].play();
            } else {
                autoPlay = (true);
                if (_arg4 != undefined) {
                    totalTime = (_arg4);
                }
                if (_arg2 != undefined) {
                    isLive = (_arg2);
                }
                contentPath = (_arg3);
            }
        }
        function pause() {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            _vp[_activeVP].pause();
        }
        function stop() {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            _vp[_activeVP].stop();
        }
        function seek(_arg2) {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            _preSeekTime = playheadTime;
            _vp[_activeVP].seek(_arg2);
        }
        function seekSeconds(_arg2) {
            this.seek(_arg2);
        }
        function seekPercent(_arg2) {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            if (((((_arg2 < 0) || (_arg2 > 100)) || (_vp[_activeVP].totalTime == undefined)) || (_vp[_activeVP].totalTime == null)) || (_vp[_activeVP].totalTime <= 0)) {
                throw new mx.video.VideoError(mx.video.VideoError.INVALID_SEEK);
            }
            this.seek((_vp[_activeVP].totalTime * _arg2) / 100);
        }
        function get playheadPercentage() {
            if (((_vp[_activeVP].totalTime == undefined) || (_vp[_activeVP].totalTime == null)) || (_vp[_activeVP].totalTime <= 0)) {
                return(undefined);
            }
            return((_vp[_activeVP].playheadTime / _vp[_activeVP].totalTime) * 100);
        }
        function set playheadPercentage(_arg2) {
            seekPercent(_arg2);
            //return(playheadPercentage);
        }
        function seekToNavCuePoint(_arg4) {
            var _local3;
            switch (typeof(_arg4)) {
                case ""string"" : 
                    _local3 = {name:_arg4};
                    break;
                case ""number"" : 
                    _local3 = {time:_arg4};
                    break;
                case ""object"" : 
                    _local3 = _arg4;
                    break;
            }
            if (((_local3.name == null) || (_local3.name == undefined)) || (typeof(_local3.name) != ""string"")) {
                seekToNextNavCuePoint(_local3.time);
                return(undefined);
            }
            if (isNaN(_local3.time)) {
                _local3.time = 0;
            }
            var _local2 = findNearestCuePoint(_arg4, NAVIGATION);
            while ((_local2 != null) && ((_local2.time < _local3.time) || (!isFLVCuePointEnabled(_local2)))) {
                _local2 = findNextCuePointWithName(_local2);
            }
            if (_local2 == null) {
                throw new mx.video.VideoError(mx.video.VideoError.INVALID_SEEK);
            }
            this.seek(_local2.time);
        }
        function seekToNextNavCuePoint(_arg4) {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            if (isNaN(_arg4) || (_arg4 < 0)) {
                _arg4 = _vp[_activeVP].playheadTime + 0.001;
            }
            var _local3;
            _local3 = findNearestCuePoint(_arg4, NAVIGATION);
            if (_local3 == null) {
                this.seek(_vp[_activeVP].totalTime);
                return(undefined);
            }
            var _local2 = _local3.index;
            if (_local3.time < _arg4) {
                _local2++;
            }
            while ((_local2 < _local3[""array""].length) && (!isFLVCuePointEnabled(_local3[""array""][_local2]))) {
                _local2++;
            }
            if (_local2 >= _local3[""array""].length) {
                var _local5 = _vp[_activeVP].totalTime;
                if (_local3[""array""][_local3[""array""].length - 1].time > _local5) {
                    _local5 = _local3[""array""][_local3[""array""].length - 1];
                }
                this.seek(_local5);
            } else {
                this.seek(_local3[""array""][_local2].time);
            }
        }
        function seekToPrevNavCuePoint(_arg4) {
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            if (isNaN(_arg4) || (_arg4 < 0)) {
                _arg4 = _vp[_activeVP].playheadTime;
            }
            var _local3 = findNearestCuePoint(_arg4, NAVIGATION);
            if (_local3 == null) {
                this.seek(0);
                return(undefined);
            }
            var _local2 = _local3.index;
            while ((_local2 >= 0) && ((!isFLVCuePointEnabled(_local3[""array""][_local2])) || (_local3[""array""][_local2].time >= (_arg4 - _seekToPrevOffset)))) {
                _local2--;
            }
            if (_local2 < 0) {
                this.seek(0);
            } else {
                this.seek(_local3[""array""][_local2].time);
            }
        }
        function addASCuePoint(_arg4, _arg2, _arg3) {
            return(_cpMgr[_activeVP].addASCuePoint(_arg4, _arg2, _arg3));
        }
        function removeASCuePoint(_arg2) {
            return(_cpMgr[_activeVP].removeASCuePoint(_arg2));
        }
        function findCuePoint(_arg2, _arg3) {
            switch (_arg3) {
                case ""event"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].eventCuePoints, false, _arg2));
                case ""navigation"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].navCuePoints, false, _arg2));
                case ""flv"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].flvCuePoints, false, _arg2));
                case ""actionscript"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].asCuePoints, false, _arg2));
                case ""all"" : 
            }
            return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].allCuePoints, false, _arg2));
        }
        function findNearestCuePoint(_arg2, _arg3) {
            switch (_arg3) {
                case ""event"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].eventCuePoints, true, _arg2));
                case ""navigation"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].navCuePoints, true, _arg2));
                case ""flv"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].flvCuePoints, true, _arg2));
                case ""actionscript"" : 
                    return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].asCuePoints, true, _arg2));
                case ""all"" : 
            }
            return(_cpMgr[_activeVP].getCuePoint(_cpMgr[_activeVP].allCuePoints, true, _arg2));
        }
        function findNextCuePointWithName(_arg2) {
            return(_cpMgr[_activeVP].getNextCuePointWithName(_arg2));
        }
        function setFLVCuePointEnabled(_arg3, _arg2) {
            return(_cpMgr[_activeVP].setFLVCuePointEnabled(_arg3, _arg2));
        }
        function isFLVCuePointEnabled(_arg2) {
            return(_cpMgr[_activeVP].isFLVCuePointEnabled(_arg2));
        }
        function getNextHighestDepth() {
            var _local2 = super.getNextHighestDepth();
            return(((_local2 < 1000) ? 1000 : (_local2)));
        }
        function bringVideoPlayerToFront(_arg2) {
            if ((_arg2 == _topVP) || (_vp[_arg2] == undefined)) {
                return(undefined);
            }
            _vp[_topVP].swapDepths(_vp[_arg2].getDepth());
            _topVP = _arg2;
        }
        function getVideoPlayer(_arg2) {
            return(_vp[_arg2]);
        }
        function closeVideoPlayer(_arg2) {
            if (_vp[_arg2] == undefined) {
                return(undefined);
            }
            if (_arg2 == 0) {
                throw new mx.video.VideoError(mx.video.VideoError.DELETE_DEFAULT_PLAYER);
            }
            if (_visibleVP == _arg2) {
                visibleVideoPlayerIndex = (0);
            }
            if (_activeVP == _arg2) {
                activeVideoPlayerIndex = (0);
            }
            _vp[_arg2].close();
            _vp[_arg2].unloadMovie();
            delete _vp[_arg2];
            _vp[_arg2] = undefined;
        }
        function get activeVideoPlayerIndex() {
            return(_activeVP);
        }
        function set activeVideoPlayerIndex(_arg2) {
            if (_activeVP == _arg2) {
                return;
            }
            if (_vp[_activeVP].onEnterFrame != undefined) {
                doContentPathConnect();
            }
            _activeVP = _arg2;
            if (_vp[_activeVP] == undefined) {
                createVideoPlayer(_activeVP);
                _vp[_activeVP].visible = false;
                _vp[_activeVP].volume = 0;
            }
            //return(activeVideoPlayerIndex);
        }
        function get autoPlay() {
            if (_vpState[_activeVP] == undefined) {
                return(_autoPlay);
            }
            return(_vpState[_activeVP].autoPlay);
        }
        function set autoPlay(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _autoPlay = _arg2;
            }
            _vpState[_activeVP].autoPlay = _arg2;
            //return(autoPlay);
        }
        function get autoRewind() {
            if (_vp[_activeVP] == undefined) {
                return(_autoRewind);
            }
            return(_vp[_activeVP].autoRewind);
        }
        function set autoRewind(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _autoRewind = _arg2;
            }
            _vp[_activeVP].autoRewind = _arg2;
            //return(autoRewind);
        }
        function get autoSize() {
            if (_vp[_activeVP] == undefined) {
                return(_autoSize);
            }
            return(_vp[_activeVP].autoSize);
        }
        function set autoSize(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _autoSize = _arg2;
            }
            _vp[_activeVP].autoSize = _arg2;
            //return(autoSize);
        }
        function get bitrate() {
            return(ncMgr.getBitrate());
        }
        function set bitrate(_arg2) {
            ncMgr.setBitrate(_arg2);
            //return(bitrate);
        }
        function get buffering() {
            if (_vp[_activeVP] == undefined) {
                return(false);
            }
            return(_vp[_activeVP].state == BUFFERING);
        }
        function get bufferingBar() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _bufferingBar = _uiMgr.getControl(mx.video.UIManager.BUFFERING_BAR);
            }
            return(_bufferingBar);
        }
        function set bufferingBar(_arg2) {
            _bufferingBar = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.BUFFERING_BAR, _arg2);
            }
            //return(bufferingBar);
        }
        function get bufferingBarHidesAndDisablesOthers() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _bufferingBarHides = _uiMgr.bufferingBarHidesAndDisablesOthers;
            }
            return(_bufferingBarHides);
        }
        function set bufferingBarHidesAndDisablesOthers(_arg2) {
            _bufferingBarHides = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__bufferingBarHidesAndDisablesOthers(_arg2);
            }
            //return(bufferingBarHidesAndDisablesOthers);
        }
        function get backButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _backButton = _uiMgr.getControl(mx.video.UIManager.BACK_BUTTON);
            }
            return(_backButton);
        }
        function set backButton(_arg2) {
            _backButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.BACK_BUTTON, _arg2);
            }
            //return(backButton);
        }
        function get bufferTime() {
            if (_vp[_activeVP] == undefined) {
                return(_bufferTime);
            }
            return(_vp[_activeVP].bufferTime);
        }
        function set bufferTime(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _bufferTime = _arg2;
            }
            _vp[_activeVP].bufferTime = _arg2;
            //return(bufferTime);
        }
        function get bytesLoaded() {
            return(_vp[_activeVP].bytesLoaded);
        }
        function get bytesTotal() {
            return(_vp[_activeVP].bytesTotal);
        }
        function get contentPath() {
            if ((_vp[_activeVP] == undefined) || (_vp[_activeVP].onEnterFrame != undefined)) {
                return(_contentPath);
            }
            return(_vp[_activeVP].url);
        }
        function set contentPath(_arg3) {
            if (_global.isLivePreview) {
                return;
            }
            if (_vp[_activeVP] == undefined) {
                if (_arg3 == _contentPath) {
                    return;
                }
                _contentPath = _arg3;
            } else {
                if (_vp[_activeVP].url == _arg3) {
                    return;
                }
                _vpState[_activeVP].minProgressPercent = undefined;
                if (_vp[_activeVP].onEnterFrame != undefined) {
                    delete _vp[_activeVP].onEnterFrame;
                    _vp[_activeVP].onEnterFrame = undefined;
                }
                _cpMgr[_activeVP].reset();
                if (_vpState[_activeVP].autoPlay && (_firstStreamShown)) {
                    _vp[_activeVP].play(_arg3, _vpState[_activeVP].isLive, _vpState[_activeVP].totalTime);
                } else {
                    _vp[_activeVP].load(_arg3, _vpState[_activeVP].isLive, _vpState[_activeVP].totalTime);
                }
                _vpState[_activeVP].isLiveSet = false;
                _vpState[_activeVP].totalTimeSet = false;
            }
            //return(contentPath);
        }
        function set cuePoints(_arg2) {
            if (_cuePoints != undefined) {
                return;
            }
            _cuePoints = _arg2;
            //return(__get__cuePoints());
        }
        function get forwardButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _forwardButton = _uiMgr.getControl(mx.video.UIManager.FORWARD_BUTTON);
            }
            return(_forwardButton);
        }
        function set forwardButton(_arg2) {
            _forwardButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.FORWARD_BUTTON, _arg2);
            }
            //return(forwardButton);
        }
        function get height() {
            if (_global.isLivePreview) {
                return(__height);
            }
            if (_vp[_visibleVP] != undefined) {
                __height = _vp[_visibleVP].height;
            }
            return(__height);
        }
        function set height(_arg2) {
            setSize(width, _arg2);
            //return(height);
        }
        function get idleTimeout() {
            if (_vp[_activeVP] == undefined) {
                return(_idleTimeout);
            }
            return(_vp[_activeVP].idleTimeout);
        }
        function set idleTimeout(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _idleTimeout = _arg2;
            }
            _vp[_activeVP].idleTimeout = _arg2;
            //return(idleTimeout);
        }
        function get isRTMP() {
            if (_global.isLivePreview) {
                return(true);
            }
            if (_vp[_activeVP] == undefined) {
                return(undefined);
            }
            return(_vp[_activeVP].isRTMP);
        }
        function get isLive() {
            if (_vp[_activeVP] == undefined) {
                return(_isLive);
            } else if (_vpState[_activeVP].isLiveSet) {
                return(_vpState[_activeVP].isLive);
            } else {
                return(_vp[_activeVP].isLive);
            }
        }
        function set isLive(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _isLive = _arg2;
            }
            _vpState[_activeVP].isLive = _arg2;
            _vpState[_activeVP].isLiveSet = true;
            //return(isLive);
        }
        function get maintainAspectRatio() {
            if (_vp[_activeVP] == undefined) {
                return(_aspectRatio);
            }
            return(_vp[_activeVP].maintainAspectRatio);
        }
        function set maintainAspectRatio(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _aspectRatio = _arg2;
            }
            _vp[_activeVP].maintainAspectRatio = _arg2;
            //return(maintainAspectRatio);
        }
        function get metadata() {
            if (_vp[_activeVP] == undefined) {
                return(null);
            }
            return(_vp[_activeVP].metadata);
        }
        function get metadataLoaded() {
            if (_vp[_activeVP] == undefined) {
                return(false);
            }
            return(_cpMgr[_activeVP].metadataLoaded);
        }
        function get muteButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _muteButton = _uiMgr.getControl(mx.video.UIManager.MUTE_BUTTON);
            }
            return(_muteButton);
        }
        function set muteButton(_arg2) {
            _muteButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.MUTE_BUTTON, _arg2);
            }
            //return(muteButton);
        }
        function get ncMgr() {
            if (_vp[_activeVP] == undefined) {
                return(null);
            }
            return(_vp[_activeVP].ncMgr);
        }
        function get pauseButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _pauseButton = _uiMgr.getControl(mx.video.UIManager.PAUSE_BUTTON);
            }
            return(_pauseButton);
        }
        function set pauseButton(_arg2) {
            _pauseButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.PAUSE_BUTTON, _arg2);
            }
            //return(pauseButton);
        }
        function get paused() {
            if (_vp[_activeVP] == undefined) {
                return(false);
            }
            return(_vp[_activeVP].state == PAUSED);
        }
        function get playButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _playButton = _uiMgr.getControl(mx.video.UIManager.PLAY_BUTTON);
            }
            return(_playButton);
        }
        function set playButton(_arg2) {
            _playButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.PLAY_BUTTON, _arg2);
            }
            //return(playButton);
        }
        function get playheadTime() {
            if (_vp[_activeVP] == undefined) {
                return(0);
            }
            return(_vp[_activeVP].playheadTime);
        }
        function set playheadTime(_arg2) {
            this.seek(_arg2);
            //return(playheadTime);
        }
        function get playheadUpdateInterval() {
            if (_vp[_activeVP] == undefined) {
                return(_playheadUpdateInterval);
            }
            return(_vp[_activeVP].playheadUpdateInterval);
        }
        function set playheadUpdateInterval(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _playheadUpdateInterval = _arg2;
            }
            _cpMgr[_activeVP].playheadUpdateInterval = _arg2;
            _vp[_activeVP].playheadUpdateInterval = _arg2;
            //return(playheadUpdateInterval);
        }
        function get playing() {
            if (_vp[_activeVP] == undefined) {
                return(false);
            }
            return(_vp[_activeVP].state == PLAYING);
        }
        function get playPauseButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _playPauseButton = _uiMgr.getControl(mx.video.UIManager.PLAY_PAUSE_BUTTON);
            }
            return(_playPauseButton);
        }
        function set playPauseButton(_arg2) {
            _playPauseButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.PLAY_PAUSE_BUTTON, _arg2);
            }
            //return(playPauseButton);
        }
        function get preferredHeight() {
            if (_vp[_activeVP] == undefined) {
                return(0);
            }
            return(_vp[_activeVP].videoHeight);
        }
        function get preferredWidth() {
            if (_vp[_activeVP] == undefined) {
                return(0);
            }
            return(_vp[_activeVP].videoWidth);
        }
        function get progressInterval() {
            if (_vp[_activeVP] == undefined) {
                return(_progressInterval);
            }
            return(_vp[_activeVP].progressInterval);
        }
        function set progressInterval(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _progressInterval = _arg2;
            }
            _vp[_activeVP].progressInterval = _arg2;
            //return(progressInterval);
        }
        function get scaleX() {
            if (_vp[_visibleVP] != undefined) {
                _scaleX = (_vp[_visibleVP].width / _origWidth) * 100;
            }
            return(_scaleX);
        }
        function set scaleX(_arg2) {
            setScale(_arg2, scaleY);
            //return(scaleX);
        }
        function get scaleY() {
            if (_vp[_visibleVP] != undefined) {
                _scaleY = (_vp[_visibleVP].height / _origHeight) * 100;
            }
            return(_scaleY);
        }
        function set scaleY(_arg2) {
            setScale(scaleX, _arg2);
            //return(scaleY);
        }
        function get scrubbing() {
            var _local2 = seekBar;
            if ((_local2 == undefined) || (_local2.isDragging == undefined)) {
                return(false);
            }
            return(_local2.isDragging);
        }
        function get seekBar() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _seekBar = _uiMgr.getControl(mx.video.UIManager.SEEK_BAR);
            }
            return(_seekBar);
        }
        function set seekBar(_arg2) {
            _seekBar = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.SEEK_BAR, _arg2);
            }
            //return(seekBar);
        }
        function get seekBarInterval() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _seekBarInterval = _uiMgr.seekBarInterval;
            }
            return(_seekBarInterval);
        }
        function set seekBarInterval(_arg2) {
            _seekBarInterval = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__seekBarInterval(_seekBarInterval);
            }
            //return(seekBarInterval);
        }
        function get seekBarScrubTolerance() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _seekBarScrubTolerance = _uiMgr.seekBarScrubTolerance;
            }
            return(_seekBarScrubTolerance);
        }
        function set seekBarScrubTolerance(_arg2) {
            _seekBarScrubTolerance = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__seekBarScrubTolerance(_seekBarScrubTolerance);
            }
            //return(seekBarScrubTolerance);
        }
        function get seekToPrevOffset() {
            return(_seekToPrevOffset);
        }
        function set seekToPrevOffset(_arg2) {
            _seekToPrevOffset = _arg2;
            //return(seekToPrevOffset);
        }
        function get skin() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _skin = _uiMgr.skin;
            }
            return(_skin);
        }
        function set skin(_arg2) {
            _skin = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__skin(_arg2);
            }
            //return(skin);
        }
        function get skinAutoHide() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _skinAutoHide = _uiMgr.skinAutoHide;
            }
            return(_skinAutoHide);
        }
        function set skinAutoHide(_arg3) {
            if (_global.isLivePreview) {
                return;
            }
            _skinAutoHide = _arg3;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__skinAutoHide(_arg3);
            }
            //return(skinAutoHide);
        }
        function get transform() {
            return(_transform);
        }
        function set transform(_arg2) {
            _transform = _arg2;
            if (_vp[_activeVP] != undefined) {
                _vp[_activeVP].transform = _transform;
            }
            //return(transform);
        }
        function get state() {
            if (_global.isLivePreview) {
                return(STOPPED);
            }
            if (_vp[_activeVP] == undefined) {
                return(DISCONNECTED);
            }
            if ((_activeVP == _visibleVP) && (scrubbing)) {
                return(SEEKING);
            }
            var _local3 = _vp[_activeVP].state;
            if (_local3 == mx.video.VideoPlayer.RESIZING) {
                return(LOADING);
            }
            if (((_vpState[_activeVP].prevState == LOADING) && (_vpState[_activeVP].autoPlay)) && (_local3 == STOPPED)) {
                return(LOADING);
            }
            return(_local3);
        }
        function get stateResponsive() {
            if (_vp[_activeVP] == undefined) {
                return(false);
            }
            return(_vp[_activeVP].stateResponsive);
        }
        function get stopButton() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _stopButton = _uiMgr.getControl(mx.video.UIManager.STOP_BUTTON);
            }
            return(_stopButton);
        }
        function set stopButton(_arg2) {
            _stopButton = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.STOP_BUTTON, _arg2);
            }
            //return(stopButton);
        }
        function get stopped() {
            if (_vp[_activeVP] == undefined) {
                return(false);
            }
            return(_vp[_activeVP].state == STOPPED);
        }
        function get totalTime() {
            if (_global.isLivePreview) {
                return(1);
            }
            if (_vp[_activeVP] == undefined) {
                return(_totalTime);
            } else if (_vpState[_activeVP].totalTimeSet) {
                return(_vpState[_activeVP].totalTime);
            } else {
                return(_vp[_activeVP].totalTime);
            }
        }
        function set totalTime(_arg2) {
            if ((_activeVP == 0) || (_activeVP == undefined)) {
                _totalTime = _arg2;
            }
            _vpState[_activeVP].totalTime = _arg2;
            _vpState[_activeVP].totalTimeSet = true;
            //return(totalTime);
        }
        function get visible() {
            return(_visible);
        }
        function set visible(_arg2) {
            _visible = _arg2;
            //return(visible);
        }
        function get visibleVideoPlayerIndex() {
            return(_visibleVP);
        }
        function set visibleVideoPlayerIndex(_arg3) {
            if (_visibleVP == _arg3) {
                return;
            }
            var _local2 = _visibleVP;
            if (_vp[_arg3] == undefined) {
                createVideoPlayer(_arg3);
            }
            var _local5 = (_vp[_arg3].height != _vp[_visibleVP].height) || (_vp[_arg3].width != _vp[_visibleVP].width);
            _vp[_visibleVP].visible = false;
            _vp[_visibleVP].volume = 0;
            _visibleVP = _arg3;
            if (_firstStreamShown) {
                _uiMgr.setupSkinAutoHide(_local2);
                _vp[_visibleVP].visible = true;
                if (!scrubbing) {
                    _vp[_visibleVP].volume = _volume;
                }
            } else if ((_vp[_visibleVP].stateResponsive && (_vp[_visibleVP].state != DISCONNECTED)) && (_uiMgr.__get__skinReady())) {
                _uiMgr.__set__visible(true);
                _uiMgr.setupSkinAutoHide(_local2);
                _firstStreamReady = true;
                showFirstStream();
            }
            if ((_vp[_local2].height != _vp[_visibleVP].height) || (_vp[_local2].width != _vp[_visibleVP].width)) {
                dispatchEvent({type:""resize"", x:x, y:y, width:width, height:height, auto:false, vp:_visibleVP});
            }
            _uiMgr.handleEvent({type:""stateChange"", state:_vp[_visibleVP].state, vp:_visibleVP});
            _uiMgr.handleEvent({type:""playheadUpdate"", playheadTime:_vp[_visibleVP].playheadTime, vp:_visibleVP});
            if (_vp[_visibleVP].isRTMP) {
                _uiMgr.handleEvent({type:""ready"", vp:_visibleVP});
            } else {
                _uiMgr.handleEvent({type:""progress"", bytesLoaded:_vp[_visibleVP].bytesLoaded, bytesTotal:_vp[_visibleVP].bytesTotal, vp:_visibleVP});
            }
            //return(visibleVideoPlayerIndex);
        }
        function get volume() {
            return(_volume);
        }
        function set volume(_arg2) {
            if (_volume == _arg2) {
                return;
            }
            _volume = _arg2;
            if (!scrubbing) {
                _vp[_visibleVP].volume = _volume;
            }
            dispatchEvent({type:""volumeUpdate"", volume:_arg2});
            //return(volume);
        }
        function get volumeBar() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _volumeBar = _uiMgr.getControl(mx.video.UIManager.VOLUME_BAR);
            }
            return(_volumeBar);
        }
        function set volumeBar(_arg2) {
            _volumeBar = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.setControl(mx.video.UIManager.VOLUME_BAR, _arg2);
            }
            //return(volumeBar);
        }
        function get volumeBarInterval() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _volumeBarInterval = _uiMgr.volumeBarInterval;
            }
            return(_volumeBarInterval);
        }
        function set volumeBarInterval(_arg2) {
            _volumeBarInterval = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__volumeBarInterval(_volumeBarInterval);
            }
            //return(volumeBarInterval);
        }
        function get volumeBarScrubTolerance() {
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _volumeBarScrubTolerance = _uiMgr.volumeBarScrubTolerance;
            }
            return(_volumeBarScrubTolerance);
        }
        function set volumeBarScrubTolerance(_arg2) {
            _volumeBarScrubTolerance = _arg2;
            if ((_uiMgr != null) && (_uiMgr != undefined)) {
                _uiMgr.__set__volumeBarScrubTolerance(_volumeBarScrubTolerance);
            }
            //return(volumeBarScrubTolerance);
        }
        function get width() {
            if (_global.isLivePreview) {
                return(__width);
            }
            if (_vp[_visibleVP] != undefined) {
                __width = _vp[_visibleVP].width;
            }
            return(__width);
        }
        function set width(_arg2) {
            setSize(_arg2, height);
            //return(width);
        }
        function get x() {
            return(_x);
        }
        function set x(_arg2) {
            _x = _arg2;
            //return(x);
        }
        function get y() {
            return(_y);
        }
        function set y(_arg2) {
            _y = _arg2;
            //return(y);
        }
        function createVideoPlayer(_arg3) {
            if (_global.isLivePreview) {
                return(undefined);
            }
            var _local4 = width;
            var _local5 = height;
            _vp[_arg3] = mx.video.VideoPlayer(this.attachMovie(""VideoPlayer"", String(_arg3), VP_DEPTH_OFFSET + _arg3));
            _vp[_arg3].setSize(_local4, _local5);
            _topVP = _arg3;
            _vp[_arg3].autoRewind = _autoRewind;
            _vp[_arg3].autoSize = _autoSize;
            _vp[_arg3].bufferTime = _bufferTime;
            _vp[_arg3].idleTimeout = _idleTimeout;
            _vp[_arg3].maintainAspectRatio = _aspectRatio;
            _vp[_arg3].playheadUpdateInterval = _playheadUpdateInterval;
            _vp[_arg3].progressInterval = _progressInterval;
            _vp[_arg3].transform = _transform;
            _vp[_arg3].volume = _volume;
            if (_arg3 == 0) {
                _vpState[_arg3] = {id:_arg3, isLive:_isLive, isLiveSet:true, totalTime:_totalTime, totalTimeSet:true, autoPlay:_autoPlay};
                if (((_contentPath != null) && (_contentPath != undefined)) && (_contentPath != """")) {
                    _vp[_arg3].onEnterFrame = mx.utils.Delegate.create(this, doContentPathConnect);
                }
            } else {
                _vpState[_arg3] = {id:_arg3, isLive:false, isLiveSet:true, totalTime:0, totalTimeSet:true, autoPlay:false};
            }
            _vp[_arg3].addEventListener(""resize"", this);
            _vp[_arg3].addEventListener(""close"", this);
            _vp[_arg3].addEventListener(""complete"", this);
            _vp[_arg3].addEventListener(""cuePoint"", this);
            _vp[_arg3].addEventListener(""playheadUpdate"", this);
            _vp[_arg3].addEventListener(""progress"", this);
            _vp[_arg3].addEventListener(""metadataReceived"", this);
            _vp[_arg3].addEventListener(""stateChange"", this);
            _vp[_arg3].addEventListener(""ready"", this);
            _vp[_arg3].addEventListener(""rewind"", this);
            _cpMgr[_arg3] = new mx.video.CuePointManager(this, _arg3);
            _cpMgr[_arg3].playheadUpdateInterval = _playheadUpdateInterval;
        }
        function createUIManager() {
            _uiMgr = new mx.video.UIManager(this);
            _uiMgr.__set__visible(false);
            if ((_backButton != undefined) && (_backButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.BACK_BUTTON, _backButton);
            }
            if ((_bufferingBar != undefined) && (_bufferingBar != null)) {
                _uiMgr.setControl(mx.video.UIManager.BUFFERING_BAR, _bufferingBar);
            }
            _uiMgr.__set__bufferingBarHidesAndDisablesOthers(_bufferingBarHides);
            if ((_forwardButton != undefined) && (_forwardButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.FORWARD_BUTTON, _forwardButton);
            }
            if ((_pauseButton != undefined) && (_pauseButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.PAUSE_BUTTON, _pauseButton);
            }
            if ((_playButton != undefined) && (_playButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.PLAY_BUTTON, _playButton);
            }
            if ((_playPauseButton != undefined) && (_playPauseButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.PLAY_PAUSE_BUTTON, _playPauseButton);
            }
            if ((_stopButton != undefined) && (_stopButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.STOP_BUTTON, _stopButton);
            }
            if ((_seekBar != undefined) && (_seekBar != null)) {
                _uiMgr.setControl(mx.video.UIManager.SEEK_BAR, _seekBar);
            }
            if ((_seekBarInterval != undefined) && (_seekBarInterval != null)) {
                _uiMgr.__set__seekBarInterval(_seekBarInterval);
            }
            if ((_seekBarScrubTolerance != undefined) && (_seekBarScrubTolerance != null)) {
                _uiMgr.__set__seekBarScrubTolerance(_seekBarScrubTolerance);
            }
            if ((_skin != undefined) && (_skin != null)) {
                _uiMgr.__set__skin(_skin);
            }
            if ((_skinAutoHide != undefined) && (_skinAutoHide != null)) {
                _uiMgr.__set__skinAutoHide(_skinAutoHide);
            }
            if ((_muteButton != undefined) && (_muteButton != null)) {
                _uiMgr.setControl(mx.video.UIManager.MUTE_BUTTON, _muteButton);
            }
            if ((_volumeBar != undefined) && (_volumeBar != null)) {
                _uiMgr.setControl(mx.video.UIManager.VOLUME_BAR, _volumeBar);
            }
            if ((_volumeBarInterval != undefined) && (_volumeBarInterval != null)) {
                _uiMgr.__set__volumeBarInterval(_volumeBarInterval);
            }
            if ((_volumeBarScrubTolerance != undefined) && (_volumeBarScrubTolerance != null)) {
                _uiMgr.__set__volumeBarScrubTolerance(_volumeBarScrubTolerance);
            }
        }
        function createLivePreviewMovieClip() {
            preview_mc = this.createEmptyMovieClip(""preview_mc"", 10);
            preview_mc.createEmptyMovieClip(""box_mc"", 10);
            preview_mc.box_mc.beginFill(0);
            preview_mc.box_mc.moveTo(0, 0);
            preview_mc.box_mc.lineTo(0, 100);
            preview_mc.box_mc.lineTo(100, 100);
            preview_mc.box_mc.lineTo(100, 0);
            preview_mc.box_mc.lineTo(0, 0);
            preview_mc.box_mc.endFill();
            preview_mc.attachMovie(""Icon"", ""icon_mc"", 20);
        }
        function doContentPathConnect() {
            delete _vp[0].onEnterFrame;
            _vp[0].onEnterFrame = undefined;
            if (_global.isLivePreview) {
                return(undefined);
            }
            if (_vpState[0].autoPlay && (_firstStreamShown)) {
                _vp[0].play(_contentPath, _isLive, _totalTime);
            } else {
                _vp[0].load(_contentPath, _isLive, _totalTime);
            }
            _vpState[0].isLiveSet = false;
            _vpState[0].totalTimeSet = false;
        }
        function showFirstStream() {
            _firstStreamShown = true;
            _vp[_visibleVP].visible = true;
            if (!scrubbing) {
                _vp[_visibleVP].volume = _volume;
            }
            var _local2 = 0;
            while (_local2 < _vp.length) {
                if (((_vp[_local2] != undefined) && (_vp[_local2].state == STOPPED)) && (_vpState[_local2].autoPlay)) {
                    _vp[_local2].play();
                }
                _local2++;
            }
        }
        function _scrubStart() {
            var _local2 = playheadTime;
            _vp[_visibleVP].volume = 0;
            dispatchEvent({type:""stateChange"", state:SEEKING, playheadTime:_local2, vp:_visibleVP});
            dispatchEvent({type:""scrubStart"", state:SEEKING, playheadTime:_local2});
        }
        function _scrubFinish() {
            var _local3 = playheadTime;
            var _local2 = state;
            _vp[_visibleVP].volume = _volume;
            if (_local2 != SEEKING) {
                dispatchEvent({type:""stateChange"", state:_local2, playheadTime:_local3, vp:_visibleVP});
            }
            dispatchEvent({type:""scrubFinish"", state:_local2, playheadTime:_local3});
        }
        function skinError(_arg2) {
            if (_firstStreamReady && (!_firstStreamShown)) {
                showFirstStream();
            }
            dispatchEvent({type:""skinError"", message:_arg2});
        }
        function skinLoaded() {
            if (_firstStreamReady) {
                _uiMgr.__set__visible(true);
                if (!_firstStreamShown) {
                    showFirstStream();
                }
            } else if (((_contentPath == undefined) || (_contentPath == null)) || (_contentPath == """")) {
                _uiMgr.__set__visible(true);
            }
            dispatchEvent({type:""skinLoaded""});
        }
        static var version = ""1.0.0.103"";
        static var DISCONNECTED = ""disconnected"";
        static var STOPPED = ""stopped"";
        static var PLAYING = ""playing"";
        static var PAUSED = ""paused"";
        static var BUFFERING = ""buffering"";
        static var LOADING = ""loading"";
        static var CONNECTION_ERROR = ""connectionError"";
        static var REWINDING = ""rewinding"";
        static var SEEKING = ""seeking"";
        static var ALL = ""all"";
        static var EVENT = ""event"";
        static var NAVIGATION = ""navigation"";
        static var FLV = ""flv"";
        static var ACTIONSCRIPT = ""actionscript"";
        static var VP_DEPTH_OFFSET = 100;
        static var SEEK_TO_PREV_OFFSET_DEFAULT = 1;
    }
",12508,True,3144.6373741454477,median
"// =================================================================================================
//
//	Starling Framework
//	Copyright 2011-2014 Gamua. All Rights Reserved.
//
//	This program is free software. You can redistribute and/or modify it
//	in accordance with the terms of the accompanying license agreement.
//
// =================================================================================================

package starling.text
{
    import flash.display.BitmapData;
    import flash.geom.Rectangle;
    import flash.utils.ByteArray;
    
    import starling.textures.Texture;
    
    /** @private
     *  This class contains constants for the 'MINI' bitmap font. It's done that way to avoid
     *  a dependency on the 'mx.core' library (which is required for the 'Embed' statement).
     * 
     *  <p>The font is based on ""uni05_53.ttf"" from Craig Kroeger (http://www.miniml.com) and was
     *  converted to a Bitmap Font with ""GlyphDesigner"" from 71squared (http://www.71squared.com).
     *  </p> */
    internal class MiniBitmapFont
    {
        private static const BITMAP_WIDTH:int = 128;
        private static const BITMAP_HEIGHT:int = 64;
        private static const BITMAP_DATA:Array = [ 
            2027613533, 3413039936,  202148514, 2266925598, 4206886452, 4286853117,    2034947, 
            3202703399,  352977282, 2957757964, 3113652880, 2158068882, 1468709156, 2268063717, 
            2779310143, 2101025806, 3416509055, 4215794539, 3602168838, 1038056207, 1932393374, 
            3182285627, 3086802234, 1741291262, 2017257123, 3395280843,  984074419, 3049693147, 
            3986077023, 1055013549, 1806563255, 1754714962, 1577746187, 1124058786, 3888759258, 
            2482229043, 2916583666, 3743065328,  866060213, 1695195001, 2401582068, 3113347901, 
            2616521596, 1053798161, 2093370968, 4229025683,  560451479,  854767518, 2610241322, 
            4279041348, 4181572480, 4031244973,  587139110, 1081376765,  962217926,  783603325, 
            3605526425, 4102001916,  289204733, 2635140255, 3453981695, 3487854373, 2132197241, 
            3164775074, 4257640328,  770238970,  144664537,  707141570, 2934433071,  871272893, 
             512964596,  808491899,  481894297, 3095982481, 3598364156, 1710636358, 2904016319, 
            1751040139,  596966466, 1363963692,  465815609,  315567311, 4290666159, 4086022551, 
             179721458, 2221734970, 3942224988, 1519355876, 3292323782, 3933427230, 3314199893, 
            3736227348, 3846038425,  603088884, 2677349227, 3207069327, 3555275967, 3063054283, 
            3064577213, 3412044179,  693642210, 4280513949,  762928717, 1802215333, 3774849674, 
            4221155330,  970959395,  557220237, 2107226136, 3509822982, 3403284788, 4265820019, 
             898597576,  991077243, 2091615904, 3334716888,  633599866, 4218780109, 2216000376, 
             834870947, 2118009742, 1362731961,  236280636, 1274945142, 1458729366,  797960805, 
            3289369720, 2103717340, 3946406003, 2676522889, 1624104606, 1156993903, 3186170404, 
            2254499071, 1204911924, 1314218830, 3307086392, 2824275959, 3839865679, 2073394964, 
            1873329433, 1754205930, 1528429545, 1631106062, 2263272465, 4220497047, 3522893765, 
            3641376303,  707451487, 3452496787, 1390653868, 2620555793, 1027328684, 3419683476, 
            3662193703,  765701986, 3808279132,  786403271, 3824435837,  713234896, 4261856399, 
            3471930731, 3993492879, 1447960461, 1398434593, 1914230187, 2398643285, 4156374464, 
            3859339207, 3220700061, 3373248762, 3186030434, 1315917060, 2809852481, 4008553903, 
            4105611953, 1599499652, 3513857591,  877854499, 4198259455, 3648560077, 2838035419, 
            3255594190, 2465578457, 4263505201,  534904657, 2889261598, 1358214576, 1069250354, 
            3870010557, 2628896583, 3448610878,  442343309, 1024736866, 4015119133, 3250867279, 
            1513359261, 2442089596, 1944476762,  735490552,  426990058, 4234106111, 1204305707, 
            3330995265, 2398649368, 4221048123, 1724669255, 3801115709, 3489328790, 3896402933, 
            3696936939, 2836983295, 3656750393, 3349724512, 3810416287, 3654997608, 4284455103, 
            2294939563, 4207697932,  642748805, 2476981639, 2319419898,  572956615, 3833238940, 
             964924880, 2081600351, 3572458416, 2056247513, 1951368808, 2133449703, 2783728628, 
             512866577,  913279200, 1678129016, 3488578991, 3373952929, 2562996951, 3666058925, 
            1664169178, 1943591935,  750675303,  154399903, 2571590890,  852654952, 4117307766, 
            1971649621, 4180195820, 1222535348, 4283953215, 2880662236, 2717410980, 1175907705, 
            1157322027,  505963121, 2631540616, 3661227656, 3591803353, 2624126821, 1948662907, 
            3596065103, 1147387734,  256773959, 1173572460, 2361957471, 4210876076, 3080180620, 
            3464801210, 3821654259, 1465302035, 2851185457, 3143266144, 3793180414, 3368833103, 
            4274670712, 3473819108, 3487569332,  773123355, 1618635668, 2570176190, 2075248691, 
            1740805534,  288646743, 1837597401,  603556968, 3182536872,  673184603, 3088757053, 
            2897054404, 3192651316, 2885335802, 1057233368, 1118437241, 4182126463, 3110464775, 
            3313191614, 2360987274,  735505357, 2992631425, 2360928811, 4187834527,  279183208, 
            1586420003, 1174008423, 4062987589, 1162167621, 1162167621, 1162167621, 1162167621, 
            1174119799,  787274608
        ];
        
        private static const XML_DATA:XML = <font>
          <info face=""mini"" size=""8"" bold=""0"" italic=""0"" smooth=""0""/>
          <common lineHeight=""8"" base=""7"" scaleW=""128"" scaleH=""64"" pages=""1"" packed=""0""/>
          <chars count=""191"">
            <char id=""195"" x=""1"" y=""1"" width=""5"" height=""9"" xoffset=""0"" yoffset=""-2"" xadvance=""6""/>
            <char id=""209"" x=""7"" y=""1"" width=""5"" height=""9"" xoffset=""0"" yoffset=""-2"" xadvance=""6""/>
            <char id=""213"" x=""13"" y=""1"" width=""5"" height=""9"" xoffset=""0"" yoffset=""-2"" xadvance=""6""/>
            <char id=""253"" x=""19"" y=""1"" width=""4"" height=""9"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""255"" x=""24"" y=""1"" width=""4"" height=""9"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""192"" x=""29"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""193"" x=""35"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""194"" x=""41"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""197"" x=""47"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""200"" x=""53"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""201"" x=""59"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""202"" x=""65"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""210"" x=""71"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""211"" x=""77"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""212"" x=""83"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""217"" x=""89"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""218"" x=""95"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""219"" x=""101"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""221"" x=""107"" y=""1"" width=""5"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""6""/>
            <char id=""206"" x=""113"" y=""1"" width=""3"" height=""8"" xoffset=""-1"" yoffset=""-1"" xadvance=""2""/>
            <char id=""204"" x=""117"" y=""1"" width=""2"" height=""8"" xoffset=""-1"" yoffset=""-1"" xadvance=""2""/>
            <char id=""205"" x=""120"" y=""1"" width=""2"" height=""8"" xoffset=""0"" yoffset=""-1"" xadvance=""2""/>
            <char id=""36""  x=""1"" y=""11"" width=""5"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""6""/>
            <char id=""196"" x=""7"" y=""11"" width=""5"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""6""/>
            <char id=""199"" x=""13"" y=""11"" width=""5"" height=""7"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""203"" x=""19"" y=""11"" width=""5"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""6""/>
            <char id=""214"" x=""25"" y=""11"" width=""5"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""6""/>
            <char id=""220"" x=""31"" y=""11"" width=""5"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""6""/>
            <char id=""224"" x=""37"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""225"" x=""42"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""226"" x=""47"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""227"" x=""52"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""232"" x=""57"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""233"" x=""62"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""234"" x=""67"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""235"" x=""72"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""241"" x=""77"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""242"" x=""82"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""243"" x=""87"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""244"" x=""92"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""245"" x=""97"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""249"" x=""102"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""250"" x=""107"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""251"" x=""112"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""0"" xadvance=""5""/>
            <char id=""254"" x=""117"" y=""11"" width=""4"" height=""7"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""123"" x=""122"" y=""11"" width=""3"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""4""/>
            <char id=""125"" x=""1"" y=""19"" width=""3"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""4""/>
            <char id=""167"" x=""5"" y=""19"" width=""3"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""4""/>
            <char id=""207"" x=""9"" y=""19"" width=""3"" height=""7"" xoffset=""-1"" yoffset=""0"" xadvance=""2""/>
            <char id=""106"" x=""13"" y=""19"" width=""2"" height=""7"" xoffset=""0"" yoffset=""2"" xadvance=""3""/>
            <char id=""40"" x=""16"" y=""19"" width=""2"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""3""/>
            <char id=""41"" x=""19"" y=""19"" width=""2"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""3""/>
            <char id=""91"" x=""22"" y=""19"" width=""2"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""3""/>
            <char id=""93"" x=""25"" y=""19"" width=""2"" height=""7"" xoffset=""0"" yoffset=""1"" xadvance=""3""/>
            <char id=""124"" x=""28"" y=""19"" width=""1"" height=""7"" xoffset=""1"" yoffset=""1"" xadvance=""4""/>
            <char id=""81"" x=""30"" y=""19"" width=""5"" height=""6"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""163"" x=""36"" y=""19"" width=""5"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""6""/>
            <char id=""177"" x=""42"" y=""19"" width=""5"" height=""6"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""181"" x=""48"" y=""19"" width=""5"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""6""/>
            <char id=""103"" x=""54"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""112"" x=""59"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""113"" x=""64"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""121"" x=""69"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""162"" x=""74"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""228"" x=""79"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""5""/>
            <char id=""229"" x=""84"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""5""/>
            <char id=""231"" x=""89"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""240"" x=""94"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""5""/>
            <char id=""246"" x=""99"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""5""/>
            <char id=""252"" x=""104"" y=""19"" width=""4"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""5""/>
            <char id=""238"" x=""109"" y=""19"" width=""3"" height=""6"" xoffset=""-1"" yoffset=""1"" xadvance=""2""/>
            <char id=""59"" x=""113"" y=""19"" width=""2"" height=""6"" xoffset=""0"" yoffset=""3"" xadvance=""4""/>
            <char id=""236"" x=""116"" y=""19"" width=""2"" height=""6"" xoffset=""-1"" yoffset=""1"" xadvance=""2""/>
            <char id=""237"" x=""119"" y=""19"" width=""2"" height=""6"" xoffset=""0"" yoffset=""1"" xadvance=""2""/>
            <char id=""198"" x=""1"" y=""27"" width=""9"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""10""/>
            <char id=""190"" x=""11"" y=""27"" width=""8"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""9""/>
            <char id=""87"" x=""20"" y=""27"" width=""7"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""8""/>
            <char id=""188"" x=""28"" y=""27"" width=""7"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""8""/>
            <char id=""189"" x=""36"" y=""27"" width=""7"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""8""/>
            <char id=""38"" x=""44"" y=""27"" width=""6"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""7""/>
            <char id=""164"" x=""51"" y=""27"" width=""6"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""7""/>
            <char id=""208"" x=""58"" y=""27"" width=""6"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""7""/>
            <char id=""8364"" x=""65"" y=""27"" width=""6"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""7""/>
            <char id=""65"" x=""72"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""66"" x=""78"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""67"" x=""84"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""68"" x=""90"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""69"" x=""96"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""70"" x=""102"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""71"" x=""108"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""72"" x=""114"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""75"" x=""120"" y=""27"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""77"" x=""1"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""78"" x=""7"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""79"" x=""13"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""80"" x=""19"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""82"" x=""25"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""83"" x=""31"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""84"" x=""37"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""85"" x=""43"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""86"" x=""49"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""88"" x=""55"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""89"" x=""61"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""90"" x=""67"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""50"" x=""73"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""51"" x=""79"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""52"" x=""85"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""53"" x=""91"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""54"" x=""97"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""56"" x=""103"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""57"" x=""109"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""48"" x=""115"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""47"" x=""121"" y=""33"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""64"" x=""1"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""92"" x=""7"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""37"" x=""13"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""43"" x=""19"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""35"" x=""25"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""42"" x=""31"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""165"" x=""37"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""169"" x=""43"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""174"" x=""49"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""182"" x=""55"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""216"" x=""61"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""247"" x=""67"" y=""39"" width=""5"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""6""/>
            <char id=""74"" x=""73"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""76"" x=""78"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""98"" x=""83"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""100"" x=""88"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""104"" x=""93"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""107"" x=""98"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""55"" x=""103"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""63"" x=""108"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""191"" x=""113"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""222"" x=""118"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""223"" x=""123"" y=""39"" width=""4"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""5""/>
            <char id=""116"" x=""1"" y=""45"" width=""3"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""60"" x=""5"" y=""45"" width=""3"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""62"" x=""9"" y=""45"" width=""3"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""170"" x=""13"" y=""45"" width=""3"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""186"" x=""17"" y=""45"" width=""3"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""239"" x=""21"" y=""45"" width=""3"" height=""5"" xoffset=""-1"" yoffset=""2"" xadvance=""2""/>
            <char id=""102"" x=""25"" y=""45"" width=""2"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""3""/>
            <char id=""49"" x=""28"" y=""45"" width=""2"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""3""/>
            <char id=""73"" x=""31"" y=""45"" width=""1"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""2""/>
            <char id=""105"" x=""33"" y=""45"" width=""1"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""2""/>
            <char id=""108"" x=""35"" y=""45"" width=""1"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""2""/>
            <char id=""33"" x=""37"" y=""45"" width=""1"" height=""5"" xoffset=""1"" yoffset=""2"" xadvance=""3""/>
            <char id=""161"" x=""39"" y=""45"" width=""1"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""3""/>
            <char id=""166"" x=""41"" y=""45"" width=""1"" height=""5"" xoffset=""0"" yoffset=""2"" xadvance=""2""/>
            <char id=""109"" x=""43"" y=""45"" width=""7"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""8""/>
            <char id=""119"" x=""51"" y=""45"" width=""7"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""8""/>
            <char id=""230"" x=""59"" y=""45"" width=""7"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""8""/>
            <char id=""97"" x=""67"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""99"" x=""72"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""101"" x=""77"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""110"" x=""82"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""111"" x=""87"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""115"" x=""92"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""117"" x=""97"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""118"" x=""102"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""120"" x=""107"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""122"" x=""112"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""215"" x=""117"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""248"" x=""122"" y=""45"" width=""4"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""114"" x=""1"" y=""51"" width=""3"" height=""4"" xoffset=""0"" yoffset=""3"" xadvance=""4""/>
            <char id=""178"" x=""5"" y=""51"" width=""3"" height=""4"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""179"" x=""9"" y=""51"" width=""3"" height=""4"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""185"" x=""13"" y=""51"" width=""1"" height=""4"" xoffset=""0"" yoffset=""2"" xadvance=""2""/>
            <char id=""61"" x=""15"" y=""51"" width=""5"" height=""3"" xoffset=""0"" yoffset=""3"" xadvance=""6""/>
            <char id=""171"" x=""21"" y=""51"" width=""5"" height=""3"" xoffset=""0"" yoffset=""3"" xadvance=""6""/>
            <char id=""172"" x=""27"" y=""51"" width=""5"" height=""3"" xoffset=""0"" yoffset=""4"" xadvance=""6""/>
            <char id=""187"" x=""33"" y=""51"" width=""5"" height=""3"" xoffset=""0"" yoffset=""3"" xadvance=""6""/>
            <char id=""176"" x=""39"" y=""51"" width=""3"" height=""3"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""44"" x=""43"" y=""51"" width=""2"" height=""3"" xoffset=""0"" yoffset=""6"" xadvance=""3""/>
            <char id=""58"" x=""46"" y=""51"" width=""1"" height=""3"" xoffset=""1"" yoffset=""3"" xadvance=""4""/>
            <char id=""94"" x=""48"" y=""51"" width=""4"" height=""2"" xoffset=""-1"" yoffset=""2"" xadvance=""4""/>
            <char id=""126"" x=""53"" y=""51"" width=""4"" height=""2"" xoffset=""0"" yoffset=""3"" xadvance=""5""/>
            <char id=""34"" x=""58"" y=""51"" width=""3"" height=""2"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""96"" x=""62"" y=""51"" width=""2"" height=""2"" xoffset=""0"" yoffset=""2"" xadvance=""3""/>
            <char id=""180"" x=""65"" y=""51"" width=""2"" height=""2"" xoffset=""0"" yoffset=""2"" xadvance=""3""/>
            <char id=""184"" x=""68"" y=""51"" width=""2"" height=""2"" xoffset=""0"" yoffset=""7"" xadvance=""3""/>
            <char id=""39"" x=""71"" y=""51"" width=""1"" height=""2"" xoffset=""0"" yoffset=""2"" xadvance=""2""/>
            <char id=""95"" x=""73"" y=""51"" width=""5"" height=""1"" xoffset=""0"" yoffset=""7"" xadvance=""6""/>
            <char id=""45"" x=""79"" y=""51"" width=""4"" height=""1"" xoffset=""0"" yoffset=""4"" xadvance=""5""/>
            <char id=""173"" x=""84"" y=""51"" width=""4"" height=""1"" xoffset=""0"" yoffset=""4"" xadvance=""5""/>
            <char id=""168"" x=""89"" y=""51"" width=""3"" height=""1"" xoffset=""1"" yoffset=""2"" xadvance=""5""/>
            <char id=""175"" x=""93"" y=""51"" width=""3"" height=""1"" xoffset=""0"" yoffset=""2"" xadvance=""4""/>
            <char id=""46"" x=""97"" y=""51"" width=""1"" height=""1"" xoffset=""0"" yoffset=""6"" xadvance=""2""/>
            <char id=""183"" x=""99"" y=""51"" width=""1"" height=""1"" xoffset=""0"" yoffset=""4"" xadvance=""2""/>
            <char id=""32"" x=""6"" y=""56"" width=""0"" height=""0"" xoffset=""0"" yoffset=""127"" xadvance=""3""/>
          </chars>
        </font>;
        
        public static function get texture():Texture
        {
            var bitmapData:BitmapData = getBitmapData();
            var texture:Texture = Texture.fromBitmapData(bitmapData, false);
            bitmapData.dispose();
            bitmapData = null;

            texture.root.onRestore = function():void
            {
                bitmapData = getBitmapData();
                texture.root.uploadBitmapData(bitmapData);
                bitmapData.dispose();
                bitmapData = null;
            };

            return texture;
        }

        private static function getBitmapData():BitmapData
        {
            var bmpData:BitmapData = new BitmapData(BITMAP_WIDTH, BITMAP_HEIGHT);
            var bmpBytes:ByteArray = new ByteArray();
            var numBytes:int = BITMAP_DATA.length;
            
            for (var i:int=0; i<numBytes; ++i)
                bmpBytes.writeUnsignedInt(BITMAP_DATA[i]);
            
            bmpBytes.uncompress();
            bmpData.setPixels(new Rectangle(0, 0, BITMAP_WIDTH, BITMAP_HEIGHT), bmpBytes);
            bmpBytes.clear();
            
            return bmpData;
        }
        
        public static function get xml():XML { return XML_DATA; }
    }
}",12354,True,3238.7744894228285,median
"/*
Feathers
Copyright 2012-2020 Bowler Hat LLC. All Rights Reserved.

This program is free software. You can redistribute and/or modify it in
accordance with the terms of the accompanying license agreement.
*/
package feathers.media
{
	import feathers.controls.AutoSizeMode;
	import feathers.controls.LayoutGroup;
	import feathers.core.PopUpManager;
	import feathers.events.FeathersEventType;
	import feathers.events.MediaPlayerEventType;
	import feathers.skins.IStyleProvider;

	import flash.display.Stage;
	import flash.display.StageDisplayState;
	import flash.errors.IllegalOperationError;
	import flash.events.FullScreenEvent;
	import flash.events.IOErrorEvent;
	import flash.events.NetStatusEvent;
	import flash.media.SoundTransform;
	import flash.net.NetConnection;
	import flash.net.NetStream;

	import starling.core.Starling;
	import starling.display.DisplayObject;
	import starling.events.Event;
	import starling.rendering.Painter;
	import starling.textures.Texture;

	/**
	 * Dispatched when the original native width or height of the video content
	 * is calculated.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see #nativeWidth
	 * @see #nativeHeight
	 *
	 * @eventType feathers.events.MediaPlayerEventType.DIMENSIONS_CHANGE
	 */
	[Event(name=""dimensionsChange"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the media player changes to the full-screen display mode
	 * or back to the normal display mode. The value of the
	 * <code>isFullScreen</code> property indicates if the media player is
	 * displayed in full screen mode or normally. 
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see #isFullScreen
	 * @see #toggleFullScreen()
	 *
	 * @eventType feathers.events.MediaPlayerEventType.DISPLAY_STATE_CHANGE
	 */
	[Event(name=""displayStateChange"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the media player's sound transform changes.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see #soundTransform
	 *
	 * @eventType feathers.events.MediaPlayerEventType.SOUND_TRANSFORM_CHANGE
	 */
	[Event(name=""soundTransformChange"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the video metadata becomes available with the
	 * <code>onMetaData</code> callback from the <code>NetStream</code> instance.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>The metadata object passed with the
	 *   <code>onMetaData</code> callback from the <code>NetStream</code>.</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 * 
	 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStream.html#event:onMetaData flash.net.NetStream onMetaData callback
	 *
	 * @eventType feathers.events.MediaPlayerEventType.METADATA_RECEIVED
	 */
	[Event(name=""metadataReceived"",type=""starling.events.Event"")]

	/**
	 * Dispatched when a cue point is reached with the <code>onCuePoint</code>
	 * callback from the <code>NetStream</code> instance.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>The cue point object passed with the
	 *   <code>onCuePoint</code> callback from the <code>NetStream</code>.</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStream.html#event:onCuePoint flash.net.NetStream onCuePoint callback
	 *
	 * @eventType feathers.events.MediaPlayerEventType.CUE_POINT
	 */
	[Event(name=""metadataReceived"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the video texture is ready to be rendered. Indicates that
	 * the <code>texture</code> property will return a
	 * <code>starling.textures.Texture</code> that may be displayed in an
	 * <code>ImageLoader</code> or another component.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 * 
	 * @see #texture
	 *
	 * @eventType starling.events.Event.READY
	 */
	[Event(name=""ready"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the video texture is no longer valid. Indicates that
	 * the <code>texture</code> property will return a <code>null</code> value,
	 * and that that the previous texture has been disposed and should not be
	 * rendered any more.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>null</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see #texture
	 *
	 * @eventType feathers.events.FeathersEventType.CLEAR
	 */
	[Event(name=""clear"",type=""starling.events.Event"")]

	/**
	 * Dispatched periodically when a media player's content is loading to
	 * indicate the current progress. The <code>bytesLoaded</code> and
	 * <code>bytesTotal</code> properties may be accessed to determine the
	 * exact number of bytes loaded.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>A numeric value between <code>0</code>
	 *   and <code>1</code> that indicates how much of the media has loaded so far.</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see #bytesLoaded
	 * @see #bytesTotal
	 *
	 * @eventType feathers.events.MediaPlayerEventType.LOAD_PROGRESS
	 */
	[Event(name=""loadProgress"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the <code>flash.net.NetStream</code> object dispatches
	 * <code>flash.events.IOErrorEvent.IO_ERROR</code>.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>The <code>flash.events.IOErrorEvent</code>
	 *   dispatched by the <code>flash.net.NetStream</code>.</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStream.html#event:ioError flash.net.NetStream: flash.events.IOErrorEvent.IO_ERROR
	 *
	 * @eventType starling.events.Event.IO_ERROR
	 */
	[Event(name=""ioError"",type=""starling.events.Event"")]

	/**
	 * Dispatched when the <code>flash.net.NetStream</code> object dispatches
	 * <code>flash.events.NetStatusEvent.NET_STATUS</code> with certain error
	 * codes.
	 *
	 * <p>The properties of the event object have the following values:</p>
	 * <table class=""innertable"">
	 * <tr><th>Property</th><th>Value</th></tr>
	 * <tr><td><code>bubbles</code></td><td>false</td></tr>
	 * <tr><td><code>currentTarget</code></td><td>The Object that defines the
	 *   event listener that handles the event. For example, if you use
	 *   <code>myButton.addEventListener()</code> to register an event listener,
	 *   myButton is the value of the <code>currentTarget</code>.</td></tr>
	 * <tr><td><code>data</code></td><td>The code from the event.</td></tr>
	 * <tr><td><code>target</code></td><td>The Object that dispatched the event;
	 *   it is not always the Object listening for the event. Use the
	 *   <code>currentTarget</code> property to always access the Object
	 *   listening for the event.</td></tr>
	 * </table>
	 *
	 * @eventType feathers.events.FeathersEventType.ERROR
	 */
	[Event(name=""error"",type=""starling.events.Event"")]

	/**
	 * Controls playback of video with a <code>flash.net.NetStream</code> object.
	 *
	 * @see ../../../help/video-player.html How to use the Feathers VideoPlayer component
	 *
	 * @productversion Feathers 2.2.0
	 */
	public class VideoPlayer extends BaseTimedMediaPlayer implements IVideoPlayer, IProgressiveMediaPlayer
	{
		/**
		 * @private
		 */
		protected static const NET_STATUS_CODE_NETCONNECTION_CONNECT_SUCCESS:String = ""NetConnection.Connect.Success"";

		/**
		 * @private
		 */
		protected static const NET_STATUS_CODE_NETSTREAM_PLAY_START:String = ""NetStream.Play.Start"";

		/**
		 * @private
		 */
		protected static const NET_STATUS_CODE_NETSTREAM_PLAY_STOP:String = ""NetStream.Play.Stop"";

		/**
		 * @private
		 */
		protected static const NET_STATUS_CODE_NETSTREAM_PLAY_STREAMNOTFOUND:String = ""NetStream.Play.StreamNotFound"";

		/**
		 * @private
		 */
		protected static const NET_STATUS_CODE_NETSTREAM_PLAY_NOSUPPORTEDTRACKFOUND:String = ""NetStream.Play.NoSupportedTrackFound"";

		/**
		 * @private
		 */
		protected static const NO_VIDEO_SOURCE_PLAY_ERROR:String = ""Cannot play media when videoSource property has not been set."";

		/**
		 * @private
		 */
		protected static const NO_VIDEO_SOURCE_PAUSE_ERROR:String = ""Cannot pause media when videoSource property has not been set."";

		/**
		 * @private
		 */
		protected static const NO_VIDEO_SOURCE_SEEK_ERROR:String = ""Cannot seek media when videoSource property has not been set."";
		
		/**
		 * The default <code>IStyleProvider</code> for all
		 * <code>VideoPlayer</code> components.
		 *
		 * @default null
		 * @see feathers.core.FeathersControl#styleProvider
		 */
		public static var globalStyleProvider:IStyleProvider;

		/**
		 * @private
		 */
		protected static function defaultNetConnectionFactory():NetConnection
		{
			var connection:NetConnection = new NetConnection();
			connection.connect(null);
			return connection;
		}

		/**
		 * @private
		 */
		protected static function defaultNetStreamFactory(netConnection:NetConnection):NetStream
		{
			return new NetStream(netConnection);
		}
		
		/**
		 * Constructor.
		 */
		public function VideoPlayer()
		{
			super();
		}

		/**
		 * @private
		 */
		override protected function get defaultStyleProvider():IStyleProvider
		{
			return VideoPlayer.globalStyleProvider;
		}

		/**
		 * @private
		 */
		protected var _fullScreenContainer:LayoutGroup;

		/**
		 * @private
		 */
		protected var _ignoreDisplayListEvents:Boolean = false;

		/**
		 * @private
		 */
		protected var _soundTransform:SoundTransform;

		/**
		 * @inheritDoc
		 *
		 * <p>In the following example, the audio is muted:</p>
		 *
		 * <listing version=""3.0"">
		 * videoPlayer.soundTransform = new SoundTransform(0);</listing>
		 *
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/media/SoundTransform.html flash.media.SoundTransform
		 * @see #event:soundTransformChange feathers.events.MediaPlayerEventType.SOUND_TRANSFORM_CHANGE
		 */
		public function get soundTransform():SoundTransform
		{
			if(!this._soundTransform)
			{
				this._soundTransform = new SoundTransform();
			}
			return this._soundTransform;
		}

		/**
		 * @private
		 */
		public function set soundTransform(value:SoundTransform):void
		{
			this._soundTransform = value;
			if(this._netStream)
			{
				this._netStream.soundTransform = this._soundTransform;
			}
			this.dispatchEventWith(MediaPlayerEventType.SOUND_TRANSFORM_CHANGE);
		}

		/**
		 * @private
		 */
		protected var _isWaitingForTextureReady:Boolean = false;

		/**
		 * @private
		 */
		protected var _texture:Texture;

		/**
		 * The texture used to display the video. This texture is not
		 * automatically rendered by the <code>VideoPlayer</code> component. A
		 * component like an <code>ImageLoader</code> should be added as a child
		 * of the <code>VideoPlayer</code> to display the texture when it is
		 * ready.
		 * 
		 * <p>The <code>texture</code> property will initially return
		 * <code>null</code>. Listen for <code>Event.READY</code> to know when
		 * a valid texture is available to render.</p>
		 * 
		 * <p>In the following example, a listener is added for
		 * <code>Event.READY</code>, and the texture is displayed by an
		 * <code>ImageLoader</code> component:</p>
		 * 
		 * <listing version=""3.0"">
		 * function videoPlayer_readyHandler( event:Event ):void
		 * {
		 *     var view:ImageLoader = new ImageLoader();
		 *     view.source = videoPlayer.texture;
		 *     videoPlayer.addChildAt(view, 0);
		 * }
		 * 
		 * videoPlayer.addEventListener( Event.READY, videoPlayer_readyHandler );</listing>
		 * 
		 * @see #event:ready starling.events.Event.READY
		 * @see feathers.controls.ImageLoader
		 */
		public function get texture():Texture
		{
			//there can be runtime errors if the texture is rendered before it
			//is ready, so we must return null until we're sure it's safe
			if(this._isWaitingForTextureReady)
			{
				return null;
			}
			return this._texture;
		}

		/**
		 * @inheritDoc
		 *
		 * @see #event:dimensionsChange feathers.events.MediaPlayerEventType.DIMENSIONS_CHANGE
		 */
		public function get nativeWidth():Number
		{
			if(this._texture)
			{
				return this._texture.nativeWidth;
			}
			return 0;
		}

		/**
		 * @inheritDoc
		 *
		 * @see #event:dimensionsChange feathers.events.MediaPlayerEventType.DIMENSIONS_CHANGE
		 */
		public function get nativeHeight():Number
		{
			if(this._texture)
			{
				return this._texture.nativeHeight;
			}
			return 0;
		}

		/**
		 * @private
		 */
		protected var _netConnection:NetConnection;

		/**
		 * @private
		 */
		protected var _netStream:NetStream;

		/**
		 * The <code>flash.net.NetStream</code> object used to play the video.
		 * 
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStream.html flash.net.NetStream
		 */
		public function get netStream():NetStream
		{
			return this._netStream;
		}

		/**
		 * @private
		 */
		protected var _hasPlayedToEnd:Boolean = false;

		/**
		 * @private
		 */
		protected var _videoSource:String;

		/**
		 * A string representing the video URL or any other accepted value that
		 * may be passed to the <code>play()</code> function of a
		 * <code>NetStream</code> object.
		 * 
		 * <p>In the following example, a video file URL is passed in:</p>
		 * 
		 * <listing version=""3.0"">
		 * videoPlayer.videoSource = ""http://example.com/video.m4v"";</listing>
		 * 
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStream.html#play() Full description of flash.net.NetStream.play() in Adobe's Flash Platform API Reference
		 */
		public function get videoSource():String
		{
			return this._videoSource;
		}

		/**
		 * @private
		 */
		public function set videoSource(value:String):void
		{
			if(this._videoSource === value)
			{
				return;
			}
			if(this._isPlaying)
			{
				this.stop();
			}
			this.disposeNetStream();
			if(!value)
			{
				this.disposeNetConnection();
			}
			if(this._texture !== null)
			{
				this._texture.dispose();
				this._texture = null;
				this.dispatchEventWith(FeathersEventType.CLEAR);
			}
			this._videoSource = value;
			//reset the current and total time if we were playing a different
			//video previously
			if(this._currentTime != 0)
			{
				this._currentTime = 0;
				this.dispatchEventWith(MediaPlayerEventType.CURRENT_TIME_CHANGE);
			}
			if(this._totalTime != 0)
			{
				this._totalTime = 0;
				this.dispatchEventWith(MediaPlayerEventType.TOTAL_TIME_CHANGE);
			}
			//same with the bytes loaded and total
			this._bytesLoaded = 0;
			this._bytesTotal = 0;
			if(this._autoPlay && this._videoSource)
			{
				this.play();
			}
		}

		/**
		 * @private
		 */
		protected var _autoPlay:Boolean = true;

		/**
		 * Determines if the video starts playing immediately when the
		 * <code>videoSource</code> property is set.
		 *
		 * <p>In the following example, automatic playback is disabled:</p>
		 *
		 * <listing version=""3.0"">
		 * videoPlayer.autoPlay = false;</listing>
		 *
		 * @see #videoSource
		 */
		public function get autoPlay():Boolean
		{
			return this._autoPlay;
		}

		/**
		 * @private
		 */
		public function set autoPlay(value:Boolean):void
		{
			this._autoPlay = value;
		}

		/**
		 * @private
		 */
		protected var _isFullScreen:Boolean = false;

		/**
		 * Indicates if the video player is currently full screen or not. When
		 * the player is full screen, it will be displayed as a modal pop-up
		 * that fills the entire Starling stage. Depending on the value of
		 * <code>fullScreenDisplayState</code>, it may also change the value of
		 * the native stage's <code>displayState</code> property.
		 * 
		 * @see #toggleFullScreen()
		 * @see #event:displayStateChange feathers.events.MediaPlayerEventType.DISPLAY_STATE_CHANGE
		 */
		public function get isFullScreen():Boolean
		{
			return this._isFullScreen;
		}

		/**
		 * @private
		 */
		protected var _normalDisplayState:String = StageDisplayState.NORMAL;

		[Inspectable(type=""String"",enumeration=""fullScreenInteractive,fullScreen,normal"")]
		/**
		 * When the video player is displayed normally (in other words, when it
		 * isn't full-screen), determines the value of the native stage's
		 * <code>displayState</code> property.
		 * 
		 * <p>Using this property, it is possible to set the native stage's
		 * <code>displayState</code> property to
		 * <code>StageDisplayState.FULL_SCREEN_INTERACTIVE</code> or
		 * <code>StageDisplayState.FULL_SCREEN</code> when the video player
		 * is not in full screen mode. This might be useful for mobile apps that
		 * should always display in full screen, while allowing a video player
		 * to toggle between filling the entire stage and displaying at a
		 * smaller size within its parent's layout.</p>
		 *
		 * <p>In the following example, the display state for normal mode
		 * is changed:</p>
		 *
		 * <listing version=""3.0"">
		 * videoPlayer.fullScreenDisplayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;</listing>
		 *
		 * @default StageDisplayState.NORMAL
		 *
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/StageDisplayState.html#FULL_SCREEN_INTERACTIVE StageDisplayState.FULL_SCREEN_INTERACTIVE
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/StageDisplayState.html#FULL_SCREEN StageDisplayState.FULL_SCREEN
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/StageDisplayState.html#NORMAL StageDisplayState.NORMAL
		 * @see #fullScreenDisplayState
		 */
		public function get normalDisplayState():String
		{
			return this._normalDisplayState;
		}

		/**
		 * @private
		 */
		public function set normalDisplayState(value:String):void
		{
			if(this._normalDisplayState == value)
			{
				return;
			}
			this._normalDisplayState = value;
			if(!this._isFullScreen && this.stage)
			{
				var starling:Starling = this.stage.starling;
				var nativeStage:Stage = starling.nativeStage;
				nativeStage.displayState = this._normalDisplayState;
			}
		}

		/**
		 * @private
		 */
		protected var _fullScreenDisplayState:String = StageDisplayState.FULL_SCREEN_INTERACTIVE;

		[Inspectable(type=""String"",enumeration=""fullScreenInteractive,fullScreen,normal"")]
		/**
		 * When the video player is displayed full-screen, determines the value
		 * of the native stage's <code>displayState</code> property.
		 *
		 * <p>Using this property, it is possible to set the native stage's
		 * <code>displayState</code> property to
		 * <code>StageDisplayState.NORMAL</code> when the video player is in
		 * full screen mode. The video player will still be displayed as a modal
		 * pop-up that fills the entire Starling stage, in this situation.</p>
		 * 
		 * <p>In the following example, the display state for full-screen mode
		 * is changed:</p>
		 * 
		 * <listing version=""3.0"">
		 * videoPlayer.fullScreenDisplayState = StageDisplayState.FULL_SCREEN;</listing>
		 * 
		 * @default StageDisplayState.FULL_SCREEN_INTERACTIVE
		 * 
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/StageDisplayState.html#FULL_SCREEN_INTERACTIVE StageDisplayState.FULL_SCREEN_INTERACTIVE
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/StageDisplayState.html#FULL_SCREEN StageDisplayState.FULL_SCREEN
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/StageDisplayState.html#NORMAL StageDisplayState.NORMAL
		 * @see #normalDisplayState
		 */
		public function get fullScreenDisplayState():String
		{
			return this._fullScreenDisplayState;
		}

		/**
		 * @private
		 */
		public function set fullScreenDisplayState(value:String):void
		{
			if(this._fullScreenDisplayState == value)
			{
				return;
			}
			this._fullScreenDisplayState = value;
			if(this._isFullScreen && this.stage)
			{
				var starling:Starling = this.stage.starling;
				var nativeStage:Stage = starling.nativeStage;
				nativeStage.displayState = this._fullScreenDisplayState;
			}
		}

		/**
		 * @private
		 */
		protected var _hideRootWhenFullScreen:Boolean = true;

		/**
		 * Determines if the Starling root display object is hidden when the
		 * video player switches to full screen mode. By hiding the root display
		 * object, rendering performance is optimized because Starling skips a
		 * portion of the display list that is obscured by the video player.
		 *
		 * <p>In the following example, the root display object isn't hidden
		 * when the video player is displayed in full screen:</p>
		 *
		 * <listing version=""3.0"">
		 * videoPlayer.hideRootWhenFullScreen = false;</listing>
		 *
		 * @default true
		 */
		public function get hideRootWhenFullScreen():Boolean
		{
			return this._hideRootWhenFullScreen;
		}

		/**
		 * @private
		 */
		public function set hideRootWhenFullScreen(value:Boolean):void
		{
			this._hideRootWhenFullScreen = value;
		}

		/**
		 * @private
		 */
		protected var _netConnectionFactory:Function = defaultNetConnectionFactory;

		/**
		 * Creates the <code>flash.net.NetConnection</code> object used to play
		 * the video, and calls the <code>connect()</code> method. By default, a
		 * value of <code>null</code> is passed to the <code>connect()</code>
		 * method. To pass different parameters, you may use a custom
		 * <code>netConnectionFactory</code>.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 * <pre>function():NetConnection</pre>
		 *
		 * <p>In the following example, a custom factory for the
		 * <code>NetConnection</code> is passed to the video player:</p>
		 *
		 * <listing version=""3.0"">
		 * videoPlayer.netConnectionFactory = function():NetConnection
		 * {
		 *     var connection:NetConnection = new NetConnection();
		 *     connection.connect( command );
		 *     return connection;
		 * };</listing>
		 * 
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetConnection.html flash.net.NetConnection
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetConnection.html#connect() flash.net.NetConnection.connect()
		 */
		public function get netConnectionFactory():Function
		{
			return this._netConnectionFactory;
		}

		/**
		 * @private
		 */
		public function set netConnectionFactory(value:Function):void
		{
			if(this._netConnectionFactory === value)
			{
				return;
			}
			this._netConnectionFactory = value;
			this.stop();
			this.disposeNetStream();
			this.disposeNetConnection();
		}

		/**
		 * @private
		 */
		protected var _netStreamFactory:Function = defaultNetStreamFactory;

		/**
		 * Creates the <code>flash.net.NetStream</code> object used to play
		 * the video.
		 *
		 * <p>The function is expected to have the following signature:</p>
		 * <pre>function(netConnection:NetConnection):NetStream</pre>
		 *
		 * <p>In the following example, a custom factory for the
		 * <code>NetStream</code> is passed to the video player:</p>
		 *
		 * <listing version=""3.0"">
		 * videoPlayer.netConnectionFactory = function(netConnection:NetConnection):NetStream
		 * {
		 *     var stream:NetStream = new NetStream(netConnection);
		 *     //change properties here
		 *     return stream;
		 * };</listing>
		 * 
		 * @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStream.html flash.net.NetStream
		 */
		public function get netStreamFactory():Function
		{
			return this._netStreamFactory;
		}

		/**
		 * @private
		 */
		public function set netStreamFactory(value:Function):void
		{
			if(this._netStreamFactory === value)
			{
				return;
			}
			this._netStreamFactory = value;
			this.stop();
			this.disposeNetStream();
			this.disposeNetConnection();
		}

		/**
		 * @private
		 */
		protected var _bytesLoaded:uint = 0;

		/**
		 * @copy feathers.media.IProgressiveMediaPlayer#bytesLoaded
		 *
		 * @see #bytesTotal
		 * @see #event:loadProgress feathers.events.MediaPlayerEventType.LOAD_PROGRESS
		 */
		public function get bytesLoaded():uint
		{
			return this._bytesLoaded;
		}

		/**
		 * @private
		 */
		protected var _bytesTotal:uint = 0;

		/**
		 * @copy feathers.media.IProgressiveMediaPlayer#bytesTotal
		 *
		 * @see #bytesLoaded
		 * @see #event:loadProgress feathers.events.MediaPlayerEventType.LOAD_PROGRESS
		 */
		public function get bytesTotal():uint
		{
			return this._bytesTotal;
		}

		/**
		 * @private
		 */
		override public function dispose():void
		{
			this.videoSource = null;
			super.dispose();
		}

		/**
		 * @private
		 */
		override public function play():void
		{
			if(this._videoSource === null)
			{
				return;
			}
			super.play();
		}

		/**
		 * @private
		 */
		override public function stop():void
		{
			if(this._videoSource === null)
			{
				return;
			}
			super.stop();
		}

		/**
		 * @private
		 */
		override public function render(painter:Painter):void
		{
			if(this._isFullScreen)
			{
				return;
			}
			super.render(painter);
		}

		/**
		 * Goes to full screen or returns to normal display.
		 * 
		 * <p> When the player is full screen, it will be displayed as a modal
		 * pop-up that fills the entire Starling stage. Depending on the value
		 * of <code>fullScreenDisplayState</code>, it may also change the value
		 * of the native stage's <code>displayState</code> property.</p>
		 * 
		 * <p>When the player is displaying normally (in other words, when it is
		 * not full screen), it will be displayed in its parent's layout like
		 * any other Feathers component.</p>
		 * 
		 * @see #isFullScreen
		 * @see #fullScreenDisplayState
		 * @see #normalDisplayState
		 * @see #event:displayStateChange feathers.events.MediaPlayerEventType.DISPLAY_STATE_CHANGE
		 */
		public function toggleFullScreen():void
		{
			if(!this.stage)
			{
				throw new IllegalOperationError(""Cannot enter full screen mode if the video player does not have access to the Starling stage."")
			}
			var starling:Starling = this.stage.starling;
			var nativeStage:Stage = starling.nativeStage;
			var oldIgnoreDisplayListEvents:Boolean = this._ignoreDisplayListEvents;
			this._ignoreDisplayListEvents = true;
			if(this._isFullScreen)
			{
				this.root.visible = true;
				PopUpManager.removePopUp(this._fullScreenContainer, false);
				var childCount:int = this._fullScreenContainer.numChildren;
				for(var i:int = 0; i < childCount; i++)
				{
					var child:DisplayObject = this._fullScreenContainer.getChildAt(0);
					this.addChild(child);
				}
				nativeStage.removeEventListener(FullScreenEvent.FULL_SCREEN, nativeStage_fullScreenHandler);
				nativeStage.displayState = this._normalDisplayState;
			}
			else
			{
				if(this._hideRootWhenFullScreen)
				{
					this.root.visible = false;
				}
				nativeStage.displayState = this._fullScreenDisplayState;
				if(!this._fullScreenContainer)
				{
					this._fullScreenContainer = new LayoutGroup();
					this._fullScreenContainer.autoSizeMode = AutoSizeMode.STAGE;
				}
				this._fullScreenContainer.layout = this._layout;
				childCount = this.numChildren;
				for(i = 0; i < childCount; i++)
				{
					child = this.getChildAt(0);
					this._fullScreenContainer.addChild(child);
				}
				PopUpManager.addPopUp(this._fullScreenContainer, true, false);
				nativeStage.addEventListener(FullScreenEvent.FULL_SCREEN, nativeStage_fullScreenHandler, false, 0, true);
			}
			this._ignoreDisplayListEvents = oldIgnoreDisplayListEvents;
			this._isFullScreen = !this._isFullScreen;
			this.dispatchEventWith(MediaPlayerEventType.DISPLAY_STATE_CHANGE);
		}

		/**
		 * @private
		 */
		override protected function playMedia():void
		{
			if(!this._videoSource)
			{
				throw new IllegalOperationError(NO_VIDEO_SOURCE_PLAY_ERROR);
			}
			if(this._netConnection === null)
			{
				var netConnectionFactory:Function = this._netConnectionFactory !== null ? this._netConnectionFactory : defaultNetConnectionFactory;
				this._netConnection = NetConnection(netConnectionFactory());
			}
			if(this._netStream === null)
			{
				if(!this._netConnection.connected)
				{
					//wait for the NetConnection to connect before trying to
					//create the NetStream. we'll call playMedia later.
					this._netConnection.addEventListener(NetStatusEvent.NET_STATUS, netConnection_netStatusHandler);
					return;
				}
				var netStreamFactory:Function = this._netStreamFactory !== null ? this._netStreamFactory : defaultNetStreamFactory;
				this._netStream = NetStream(netStreamFactory(this._netConnection));
				this._netStream.client = new VideoPlayerNetStreamClient(
					this.netStream_onMetaData, this.netStream_onCuePoint,
					this.netStream_onXMPData);
				this._netStream.addEventListener(NetStatusEvent.NET_STATUS, netStream_netStatusHandler);
				this._netStream.addEventListener(IOErrorEvent.IO_ERROR, netStream_ioErrorHandler);
			}
			if(this._soundTransform === null)
			{
				this._soundTransform = new SoundTransform();
			}
			this._netStream.soundTransform = this._soundTransform;
			var onCompleteCallback:Function = videoTexture_onComplete;
			if(this._texture !== null)
			{
				if(this._hasPlayedToEnd)
				{
					//after playing the media until the end, if we restart from the
					//beginning, the audio plays, but we cannot see the video.
					//however, we can ask the NetStream to play the video source
					//again from the beginning, and the video displays. if we need
					//to restore the time, we can do it after the NetStream
					//dispatches NetStream.Play.Start
					this._netStream.play(this._videoSource);
				}
				else
				{
					//this case happens if the video is paused and resumed without
					//reaching the end.
					//NetStream.Play.Start will not be dispatched after calling
					//resume(), so we need to manually add the ENTER_FRAME listener.
					//there's no need to seek. we're resuming from where the video
					//was paused.
					this.addEventListener(Event.ENTER_FRAME, videoPlayer_enterFrameHandler);
					this._netStream.resume();
				}
			}
			else
			{
				//in the final case, the texture hasn't been created yet.
				this._isWaitingForTextureReady = true;
				var starling:Starling = this.stage !== null ? this.stage.starling : Starling.current;
				this._texture = Texture.fromNetStream(this._netStream, starling.contentScaleFactor, onCompleteCallback);
				this._texture.root.onRestore = videoTexture_onRestore;
				//don't call play() until after Texture.fromNetStream() because
				//the texture needs to be created first.
				//however, we need to call play() even though a video texture
				//isn't ready to be rendered yet.
				this._netStream.play(this._videoSource);
			}
			this._hasPlayedToEnd = false;
		}

		/**
		 * @private
		 */
		override protected function pauseMedia():void
		{
			if(!this._videoSource)
			{
				throw new IllegalOperationError(NO_VIDEO_SOURCE_PAUSE_ERROR);
			}
			this.removeEventListener(Event.ENTER_FRAME, videoPlayer_enterFrameHandler);
			this._netStream.pause();
		}

		/**
		 * @private
		 */
		override protected function seekMedia(seconds:Number):void
		{
			if(!this._videoSource)
			{
				throw new IllegalOperationError(NO_VIDEO_SOURCE_SEEK_ERROR);
			}
			this._currentTime = seconds;
			if(this._hasPlayedToEnd)
			{
				//the video played until the end, which means that the current
				//texture cannot seek properly without reloading the media.
				this.playMedia();
				return;
			}
			this._netStream.seek(seconds);
		}

		/**
		 * @private
		 */
		protected function disposeNetConnection():void
		{
			if(this._netConnection === null)
			{
				return;
			}
			this._netConnection.removeEventListener(NetStatusEvent.NET_STATUS, netConnection_netStatusHandler);
			this._netConnection.close();
			this._netConnection = null;
		}

		/**
		 * @private
		 */
		protected function disposeNetStream():void
		{
			if(this._netStream === null)
			{
				return;
			}

			this.removeEventListener(Event.ENTER_FRAME, videoPlayer_progress_enterFrameHandler);

			this._netStream.removeEventListener(NetStatusEvent.NET_STATUS, netStream_netStatusHandler);
			this._netStream.removeEventListener(IOErrorEvent.IO_ERROR, netStream_ioErrorHandler);
			this._netStream.close();
			this._netStream = null;
		}

		/**
		 * @private
		 */
		protected function videoPlayer_enterFrameHandler(event:Event):void
		{
			this.setRequiresRedraw();
			this._currentTime = this._netStream.time;
			this.dispatchEventWith(MediaPlayerEventType.CURRENT_TIME_CHANGE);
		}

		/**
		 * @private
		 */
		protected function videoPlayer_progress_enterFrameHandler(event:Event):void
		{
			var newBytesTotal:Number = this._netStream.bytesTotal;
			if(newBytesTotal > 0)
			{
				var needsDispatch:Boolean = false;
				var newBytesLoaded:Number = this._netStream.bytesLoaded;
				if(this._bytesTotal != newBytesTotal)
				{
					this._bytesTotal = newBytesTotal;
					needsDispatch = true;
				}
				if(this._bytesLoaded != newBytesLoaded)
				{
					this._bytesLoaded = newBytesLoaded;
					needsDispatch = true;
				}
				if(needsDispatch)
				{
					this.dispatchEventWith(MediaPlayerEventType.LOAD_PROGRESS, false, newBytesLoaded / newBytesTotal);
				}
				if(newBytesLoaded == newBytesTotal)
				{
					this.removeEventListener(Event.ENTER_FRAME, videoPlayer_progress_enterFrameHandler);
				}
			}
		}

		/**
		 * @private
		 */
		protected function videoTexture_onRestore():void
		{
			this.pauseMedia();
			this._isWaitingForTextureReady = true;
			this._texture.root.attachNetStream(this._netStream, videoTexture_onComplete);
			//this will start playback from the beginning again, but we can seek
			//back to the current time once the video texture is ready.
			this._netStream.play(this._videoSource);
		}

		/**
		 * @private
		 */
		protected function videoTexture_onComplete():void
		{
			this._isWaitingForTextureReady = false;
			//the texture is ready to be displayed
			this.dispatchEventWith(Event.READY);
			//in many cases, the layout will be affected by the new texture
			//dimensions, so invalidate immediately
			this.invalidate(INVALIDATION_FLAG_LAYOUT);
			var bytesTotal:Number = this._netStream.bytesTotal;
			if(this._bytesTotal == 0 && bytesTotal > 0)
			{
				this._bytesLoaded = this._netStream.bytesLoaded;
				this._bytesTotal = bytesTotal;
				this.dispatchEventWith(MediaPlayerEventType.LOAD_PROGRESS, false, this._bytesLoaded / bytesTotal);
				if(this._bytesLoaded != this._bytesTotal)
				{
					this.addEventListener(Event.ENTER_FRAME, videoPlayer_progress_enterFrameHandler);
				}
			}
		}

		/**
		 * @private
		 */
		protected function netConnection_netStatusHandler(event:NetStatusEvent):void
		{
			var code:String = event.info.code;
			switch(code)
			{
				case NET_STATUS_CODE_NETCONNECTION_CONNECT_SUCCESS:
				{
					this.playMedia();
					break;
				}
			}
		}

		/**
		 * @private
		 */
		protected function netStream_onMetaData(metadata:Object):void
		{
			this.dispatchEventWith(MediaPlayerEventType.DIMENSIONS_CHANGE);
			this._totalTime = metadata.duration;
			this.dispatchEventWith(MediaPlayerEventType.TOTAL_TIME_CHANGE);
			this.dispatchEventWith(MediaPlayerEventType.METADATA_RECEIVED, false, metadata);
		}

		/**
		 * @private
		 */
		protected function netStream_onCuePoint(cuePoint:Object):void
		{
			this.dispatchEventWith(MediaPlayerEventType.CUE_POINT, false, cuePoint);
		}

		/**
		 * @private
		 */
		protected function netStream_onXMPData(xmpData:Object):void
		{
			this.dispatchEventWith(MediaPlayerEventType.XMP_DATA, false, xmpData);
		}

		/**
		 * @private
		 */
		protected function netStream_ioErrorHandler(event:IOErrorEvent):void
		{
			this.dispatchEventWith(event.type, false, event);
		}

		/**
		 * @private
		 */
		protected function netStream_netStatusHandler(event:NetStatusEvent):void
		{
			var code:String = event.info.code;
			switch(code)
			{
				case NET_STATUS_CODE_NETSTREAM_PLAY_STREAMNOTFOUND:
				{
					this.dispatchEventWith(FeathersEventType.ERROR, false, code);
					break;
				}
				case NET_STATUS_CODE_NETSTREAM_PLAY_NOSUPPORTEDTRACKFOUND:
				{
					this.dispatchEventWith(FeathersEventType.ERROR, false, code);
					break;
				}
				case NET_STATUS_CODE_NETSTREAM_PLAY_START:
				{
					if(this._netStream.time != this._currentTime)
					{
						//if we're restoring from a lost context, or we've
						//restarted the video after it had reached the end, the
						//NetStream may have restarted from the beginning. in
						//that case, we can manually seek to the last known good
						//position.
						this._netStream.seek(this._currentTime);
					}
					if(this._isPlaying)
					{
						//only add the listener if a video is playing. it may be
						//paused when restoring lost context, but we need to
						//temporarily start playing the NetStream in order to
						//restore the video texture.
						this.addEventListener(Event.ENTER_FRAME, videoPlayer_enterFrameHandler);
					}
					else
					{
						//the only way to prepare the video texture is to start
						//playing the NetStream. the media player is not in a
						//playing state, though, so we should pause the
						//NetStream now.
						this.pauseMedia();
					}
					break;
				}
				case NET_STATUS_CODE_NETSTREAM_PLAY_STOP:
				{
					if(this._hasPlayedToEnd)
					{
						//we haven't cleared this flag yet after calling play()
						//on the NetStream. it is safe to ignore this case.
						return;
					}
					
					//any time that the NetStream stops, we want to remove the
					//Event.ENTER_FRAME listener. in most cases, we don't want
					//a listener being called every frame for no reason. on iOS,
					//context loss resets the NetStream time to 0, and we need
					//to keep the current time so that we can seek back.
					this.removeEventListener(Event.ENTER_FRAME, videoPlayer_enterFrameHandler);

					//on iOS, when context is lost, the NetStream will stop
					//automatically, and the time property will be reset to 0.
					//on other platforms, the NetStream will continue playing on
					//context loss, and the time will be correct.
					//we need to check if the context is lost or not to decide
					//if we've reached the end of the video or not.
					if(Starling.context.driverInfo !== ""Disposed"")
					{
						this.stop();
						
						//set this flag after calling stop() because stopping
						//will seek to the beginning and may check for the flag.
						this._hasPlayedToEnd = true;
						this.dispatchEventWith(Event.COMPLETE);
					}
					break;
				}
			}
		}

		/**
		 * @private
		 */
		override protected function mediaPlayer_addedHandler(event:Event):void
		{
			if(this._ignoreDisplayListEvents)
			{
				return;
			}
			super.mediaPlayer_addedHandler(event);
		}

		/**
		 * @private
		 */
		override protected function mediaPlayer_removedHandler(event:Event):void
		{
			if(this._ignoreDisplayListEvents)
			{
				return;
			}
			super.mediaPlayer_removedHandler(event);
		}

		/**
		 * @private
		 */
		protected function nativeStage_fullScreenHandler(event:FullScreenEvent):void
		{
			this.toggleFullScreen();
		}
	}
}

dynamic class VideoPlayerNetStreamClient
{
	public function VideoPlayerNetStreamClient(onMetaDataCallback:Function,
		onCuePointCallback:Function, onXMPDataCallback:Function)
	{
		this.onMetaDataCallback = onMetaDataCallback;
		this.onCuePointCallback = onCuePointCallback;
		this.onXMPDataCallback = onXMPDataCallback;
	}

	public var onMetaDataCallback:Function;

	public var onCuePointCallback:Function;

	public function onMetaData(metadata:Object):void
	{
		this.onMetaDataCallback(metadata);
	}

	public function onCuePoint(cuePoint:Object):void
	{
		this.onCuePointCallback(cuePoint);
	}

	public function onXMPData(xmpData:Object):void
	{
		this.onXMPDataCallback(xmpData);
	}
}",12171,False,2228.9300171812633,median
"/**
 * VERSION: 1.67
 * DATE: 2011-04-20
 * AS3 (AS2 version is also available)
 * UPDATES AND DOCS AT: http://www.greensock.com/timelinemax/
 **/
package com.greensock {
	import com.greensock.core.TweenCore;
	import com.greensock.events.TweenEvent;

	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;
/**
 * 	TimelineMax extends TimelineLite, offering exactly the same functionality plus useful 
 *  (but non-essential) features like AS3 event dispatching, repeat, repeatDelay, yoyo, 
 *  currentLabel, addCallback(), removeCallback(), tweenTo(), tweenFromTo(), getLabelAfter(), getLabelBefore(),
 * 	and getActive() (and probably more in the future). It is the ultimate sequencing tool. 
 *  Think of a TimelineMax instance like a virtual MovieClip timeline or a container where 
 *  you place tweens (or other timelines) over the course of time. You can:
 * 	
 * <ul>
 * 		<li> build sequences easily by adding tweens with the append(), prepend(), insert(), appendMultiple(), 
 * 			prependMultiple(), and insertMultiple() methods. Tweens can overlap as much as you want and you have 
 * 			complete control over where they get placed on the timeline.</li>
 * 
 * 		<li> add labels, play(), stop(), gotoAndPlay(), gotoAndStop(), restart(), tweenTo() and even reverse()! </li>
 * 		
 * 		<li> nest timelines within timelines as deeply as you want.</li>
 * 		
 * 		<li> set the progress of the timeline using its <code>currentProgress</code> property. For example, to skip to
 * 		  the halfway point, set <code>myTimeline.currentProgress = 0.5</code>.</li>
 * 		  
 * 		<li> tween the <code>currentTime</code>, <code>totalTime</code>, <code>currentProgress</code>, or <code>totalProgress</code> 
 * 		 property to fastforward/rewind the timeline. You could 
 * 		  even attach a slider to one of these properties to give the user the ability to drag 
 * 		  forwards/backwards through the whole timeline.</li>
 * 		  
 * 		<li> add onStart, onUpdate, onComplete, onReverseComplete, and/or onRepeat callbacks using the 
 * 		  constructor's <code>vars</code> object.</li>
 * 		
 * 		<li> speed up or slow down the entire timeline with its <code>timeScale</code> property. You can even tween
 * 		  this property to gradually speed up or slow down the timeline.</li>
 * 		  
 * 		<li> use the insertMultiple(), appendMultiple(), or prependMultiple() methods to create 
 * 			complex sequences including various alignment modes and staggering capabilities.  
 * 			Works great in conjunction with TweenMax.allTo() too. </li>
 * 		  
 * 		<li> base the timing on frames instead of seconds if you prefer. Please note, however, that
 * 		  the timeline's timing mode dictates its childrens' timing mode as well. </li>
 * 		
 * 		<li> kill the tweens of a particular object inside the timeline with killTweensOf() or get the tweens of an object
 * 		  with getTweensOf() or get all the tweens/timelines in the timeline with getChildren()</li>
 * 		  
 * 		<li> set the timeline to repeat any number of times or indefinitely. You can even set a delay
 * 		  between each repeat cycle and/or cause the repeat cycles to yoyo, appearing to reverse
 * 		  every other cycle. </li>
 * 		
 * 		<li> listen for START, UPDATE, REPEAT, REVERSE_COMPLETE, and COMPLETE events.</li>
 * 		
 * 		<li> get the active tweens in the timeline with getActive().</li>
 * 
 * 		<li> add callbacks (function calls) anywhere in the timeline that call a function of your choosing when 
 * 			the ""virtual playhead"" passes a particular spot.</li>
 * 		
 * 		<li> Get the <code>currentLabel</code> or find labels at various positions in the timeline
 * 			using getLabelAfter() and getLabelBefore()</li>
 * 	</ul>
 * 	
 * <b>EXAMPLE:</b><br /><br /><code>
 * 		
 * 		import com.greensock.~~;<br /><br />
 * 		
 * 		//create the timeline and add an onComplete call to myFunction when the timeline completes<br />
 * 		var myTimeline:TimelineMax = new TimelineMax({onComplete:myFunction});<br /><br />
 * 		
 * 		//add a tween<br />
 * 		myTimeline.append(new TweenLite(mc, 1, {x:200, y:100}));<br /><br />
 * 		
 * 		//add another tween at the end of the timeline (makes sequencing easy)<br />
 * 		myTimeline.append(new TweenLite(mc, 0.5, {alpha:0}));<br /><br />
 * 		
 * 		//repeat the entire timeline twice<br />
 * 		myTimeline.repeat = 2;<br /><br />
 * 		
 * 		//delay the repeat by 0.5 seconds each time.<br />
 * 		myTimeline.repeatDelay = 0.5;<br /><br />
 * 		
 * 		//pause the timeline (stop() works too)<br />
 * 		myTimeline.pause();<br /><br />
 * 		
 * 		//reverse it anytime...<br />
 * 		myTimeline.reverse();<br /><br />
 * 		
 * 		//Add a ""spin"" label 3-seconds into the timeline.<br />
 * 		myTimeline.addLabel(""spin"", 3);<br /><br />
 * 		
 * 		//insert a rotation tween at the ""spin"" label (you could also define the insert point as the time instead of a label)<br />
 * 		myTimeline.insert(new TweenLite(mc, 2, {rotation:""360""}), ""spin""); <br /><br />
 * 		
 * 		//go to the ""spin"" label and play the timeline from there...<br />
 * 		myTimeline.gotoAndPlay(""spin"");<br /><br />
 * 
 * 		//call myCallbackwhen the ""virtual playhead"" travels past the 1.5-second point.
 * 		myTimeline.addCallback(myCallback, 1.5);
 * 		
 * 		//add a tween to the beginning of the timeline, pushing all the other existing tweens back in time<br />
 * 		myTimeline.prepend(new TweenMax(mc, 1, {tint:0xFF0000}));<br /><br />
 * 		
 * 		//nest another TimelineMax inside your timeline...<br />
 * 		var nestedTimeline:TimelineMax = new TimelineMax();<br />
 * 		nestedTimeline.append(new TweenLite(mc2, 1, {x:200}));<br />
 * 		myTimeline.append(nestedTimeline);<br /><br /></code>
 * 		
 * 		
 * 	<code>insertMultiple()</code> and <code>appendMultiple()</code> provide some very powerful sequencing tools as well, 
 *  allowing you to add an Array of tweens/timelines and optionally align them with <code>SEQUENCE</code> or <code>START</code> 
 *  modes, and even stagger them if you want. For example, to insert 3 tweens into the timeline, aligning their start times but 
 *  staggering them by 0.2 seconds, <br /><br /><code>
 * 	
 * 		myTimeline.insertMultiple([new TweenLite(mc, 1, {y:""100""}),
 * 								   new TweenLite(mc2, 1, {x:120}),
 * 								   new TweenLite(mc3, 1, {alpha:0.5})], 
 * 								   0, 
 * 								   TweenAlign.START, 
 * 								   0.2);</code><br /><br />
 * 								   
 * 	You can use the constructor's <code>vars</code> object to do all the setup too, like:<br /><br /><code>
 * 	
 * 		var myTimeline:TimelineMax = new TimelineMax({tweens:[new TweenLite(mc1, 1, {y:""100""}), TweenMax.to(mc2, 1, {tint:0xFF0000})], align:TweenAlign.SEQUENCE, onComplete:myFunction, repeat:2, repeatDelay:1});</code><br /><br />
 * 	
 * 	If that confuses you, don't worry. Just use the <code>append()</code>, <code>insert()</code>, and <code>prepend()</code> methods to build your
 * 	sequence. But power users will likely appreciate the quick, compact way they can set up sequences now. <br /><br />
 *  
 *
 * <b>NOTES:</b>
 * <ul>
 * 	<li> TimelineMax automatically inits the OverwriteManager class to prevent unexpected overwriting behavior in sequences.
 * 	  The default mode is <code>AUTO</code>, but you can set it to whatever you want with <code>OverwriteManager.init()</code>
 * 	 (see <a href=""http://www.greensock.com/overwritemanager/"">http://www.greensock.com/overwritemanager/</a>)</li>
 * 	<li> TimelineMax adds about 4.9k to your SWF (not including OverwriteManager).</li>
 * </ul>
 * 
 * <b>Copyright 2011, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href=""http://www.greensock.com/terms_of_use.html"">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
 * 
 * @author Jack Doyle, jack@greensock.com
 **/
	public class TimelineMax extends TimelineLite implements IEventDispatcher {
		/** @private **/
		public static const version:Number = 1.67;
		
		/** @private **/
		protected var _repeat:int;
		/** @private **/
		protected var _repeatDelay:Number;
		/** @private **/
		protected var _cyclesComplete:int;
		/** @private **/
		protected var _dispatcher:EventDispatcher;
		/** @private **/
		protected var _hasUpdateListener:Boolean;
		
		/** 
		 * Works in conjunction with the repeat property, determining the behavior of each cycle; when <code>yoyo</code> is true, 
		 * the timeline will go back and forth, appearing to reverse every other cycle (this has no affect on the <code>reversed</code> property though). 
		 * So if repeat is 2 and <code>yoyo</code> is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. 
		 * But if repeat is 2 and <code>yoyo</code> is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end.  
		 **/
		 public var yoyo:Boolean;
		
		/**
		 * Constructor. <br /><br />
		 * 
		 * <b>SPECIAL PROPERTIES</b><br />
		 * The following special properties may be passed in via the constructor's vars parameter, like
		 * <code>new TimelineMax({paused:true, onComplete:myFunction, repeat:2, yoyo:true})</code> 
		 * 
		 * <ul>
		 * 	<li><b> delay : Number</b>				Amount of delay in seconds (or frames for frames-based timelines) before the timeline should begin.</li>
		 * 								
		 * 	<li><b> useFrames : Boolean</b>			If <code>useFrames</code> is set to true, the timeline's timing mode will be based on frames. 
		 * 											Otherwise, it will be based on seconds/time. NOTE: a TimelineLite's timing mode is 
		 * 											always determined by its parent timeline. </li>
		 * 
		 *  <li><b> paused : Boolean</b> 			Sets the initial paused state of the timeline (by default, timelines automatically begin playing immediately)</li>
		 * 
		 * 	<li><b> reversed : Boolean</b>			If true, the timeline will be reversed initially. This does NOT force it to the very end and start 
		 * 											playing backwards. It simply affects the orientation of the timeline, so if <code>reversed</code> is set to 
		 * 											true initially, it will appear not to play because it is already at the beginning. To cause it to
		 * 											play backwards from the end, set reversed to true and then set the <code>currentProgress</code> property to 1 immediately
		 * 											after creating the timeline.</li>
		 * 									
		 * 	<li><b> tweens : Array</b>				To immediately insert several tweens into the timeline, use the <code>tweens</code> special property
		 * 											to pass in an Array of TweenLite/TweenMax/TimelineLite/TimelineMax instances. You can use this in conjunction
		 * 											with the <code>align</code> and <code>stagger</code> special properties to set up complex sequences with minimal code.
		 * 											These values simply get passed to the <code>insertMultiple()</code> method.</li>
		 * 	
		 * 	<li><b> align : String</b>				Only used in conjunction with the <code>tweens</code> special property when multiple tweens are
		 * 											to be inserted immediately through the constructor. The value simply gets passed to the 
		 * 											<code>insertMultiple()</code> method. The default is <code>TweenAlign.NORMAL</code>. Options are:
		 * 											<ul>
		 * 												<li><b> TweenAlign.SEQUENCE:</b> aligns the tweens one-after-the-other in a sequence</li>
		 * 												<li><b> TweenAlign.START:</b> aligns the start times of all of the tweens (ignores delays)</li>
		 * 												<li><b> TweenAlign.NORMAL:</b> aligns the start times of all the tweens (honors delays)</li>
		 * 											</ul>The <code>align</code> special property does <b>not</b> force all child tweens/timelines to maintain
		 * 											relative positioning, so for example, if you use TweenAlign.SEQUENCE and then later change the duration
		 * 											of one of the nested tweens, it does <b>not</b> force all subsequent timelines to change their position
		 * 											on the timeline. The <code>align</code> special property only affects the alignment of the tweens that are
		 * 											initially placed into the timeline through the <code>tweens</code> special property of the <code>vars</code> object.</li>
		 * 										
		 * 	<li><b> stagger : Number</b>			Only used in conjunction with the <code>tweens</code> special property when multiple tweens are
		 * 											to be inserted immediately. It staggers the tweens by a set amount of time (in seconds) (or
		 * 											in frames if <code>useFrames</code> is true). For example, if the stagger value is 0.5 and the <code>align</code> 
		 * 											property is set to <code>TweenAlign.START</code>, the second tween will start 0.5 seconds after the first one 
		 * 											starts, then 0.5 seconds later the third one will start, etc. If the align property is 
		 * 											<code>TweenAlign.SEQUENCE</code>, there would be 0.5 seconds added between each tween. This value simply gets 
		 * 											passed to the <code>insertMultiple()</code> method. Default is 0.</li>
		 * 	
		 * 	<li><b> onStart : Function</b>			A function that should be called when the timeline begins (the <code>currentProgress</code> won't necessarily
		 * 											be zero when onStart is called. For example, if the timeline is created and then its <code>currentProgress</code>
		 * 											property is immediately set to 0.5 or if its <code>currentTime</code> property is set to something other than zero,
		 * 											onStart will still get fired because it is the first time the timeline is getting rendered.)</li>
		 * 	
		 * 	<li><b> onStartParams : Array</b>		An Array of parameters to pass the onStart function.</li>
		 * 	
		 * 	<li><b> onUpdate : Function</b>			A function that should be called every time the timeline's time/position is updated 
		 * 											(on every frame while the timeline is active)</li>
		 * 	
		 * 	<li><b> onUpdateParams : Array</b>		An Array of parameters to pass the onUpdate function</li>
		 * 	
		 * 	<li><b> onComplete : Function</b>		A function that should be called when the timeline has finished </li>
		 * 	
		 * 	<li><b> onCompleteParams : Array</b>	An Array of parameters to pass the onComplete function</li>
		 * 	
		 * 	<li><b> onReverseComplete : Function</b> A function that should be called when the timeline has reached its starting point again after having been reversed </li>
		 * 	
		 * 	<li><b> onReverseCompleteParams : Array</b> An Array of parameters to pass the onReverseComplete functions</li>
		 *  
		 * 	<li><b> onRepeat : Function</b>			A function that should be called every time the timeline repeats </li>
		 * 	
		 * 	<li><b> onRepeatParams : Array</b>		An Array of parameters to pass the onRepeat function</li>
		 * 	
		 * 	<li><b> autoRemoveChildren : Boolean</b> If autoRemoveChildren is set to true, as soon as child tweens/timelines complete,
		 * 											they will automatically get killed/removed. This is normally undesireable because
		 * 											it prevents going backwards in time (like if you want to reverse() or set the 
		 * 											<code>currentProgress</code> value to a lower value, etc.). It can, however, improve speed and memory
		 * 											management. TweenLite's root timelines use <code>autoRemoveChildren:true</code>.</li>
		 * 
		 * 	<li><b> repeat : int</b>				Number of times that the timeline should repeat. To repeat indefinitely, use -1.</li>
		 * 	
		 * 	<li><b> repeatDelay : Number</b>		Amount of time in seconds (or frames for frames-based timelines) between repeats.</li>
		 * 	
		 * 	<li><b> yoyo : Boolean</b> 				Works in conjunction with the repeat property, determining the behavior of each 
		 * 											cycle. When <code>yoyo</code> is true, the timeline will go back and forth, appearing to reverse 
		 * 											every other cycle (this has no affect on the <code>reversed</code> property though). So if repeat is
		 * 											2 and yoyo is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. But 
		 * 											if repeat is 2 and yoyo is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end. </li>
		 * 									
		 * 	<li><b> onStartListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent when it begins.
		 * 	  										This is the same as doing <code>myTimeline.addEventListener(TweenEvent.START, myFunction);</code></li>
		 * 	
		 * 	<li><b> onUpdateListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent every time it 
		 * 											updates values.	This is the same as doing <code>myTimeline.addEventListener(TweenEvent.UPDATE, myFunction);</code></li>
		 * 	  
		 * 	<li><b> onCompleteListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent when it completes.
		 * 	  											This is the same as doing <code>myTimeline.addEventListener(TweenEvent.COMPLETE, myFunction);</code></li>
		 * 	</ul>
		 * 
		 * @param vars optionally pass in special properties like useFrames, onComplete, onCompleteParams, onUpdate, onUpdateParams, onStart, onStartParams, tweens, align, stagger, delay, autoRemoveChildren, onCompleteListener, onStartListener, onUpdateListener, repeat, repeatDelay, and/or yoyo.
		 */
		public function TimelineMax(vars:Object=null) {
			super(vars);
			_repeat = (this.vars.repeat) ? Number(this.vars.repeat) : 0;
			_repeatDelay = (this.vars.repeatDelay) ? Number(this.vars.repeatDelay) : 0;
			_cyclesComplete = 0;
			this.yoyo = Boolean(this.vars.yoyo == true);
			this.cacheIsDirty = true;
			if (this.vars.onCompleteListener != null || this.vars.onUpdateListener != null || this.vars.onStartListener != null || this.vars.onRepeatListener != null || this.vars.onReverseCompleteListener != null) {
				initDispatcher();
			}
		}
		
		/**
		 * If you want a function to be called at a particular time or label, use addCallback. When you add
		 * a callback, it is technically considered a zero-duration tween, so if you getChildren() there will be
		 * a tween returned for each callback. You can discern a callback from other tweens by the fact that
		 * their target is a function and the duration is zero. 
		 * 
		 * @param function the function to be called
		 * @param timeOrLabel the time in seconds (or frames for frames-based timelines) or label at which the callback should be inserted. For example, myTimeline.addCallback(myFunction, 3) would call myFunction() 3-seconds into the timeline, and myTimeline.addCallback(myFunction, ""myLabel"") would call it at the ""myLabel"" label.
		 * @param params an Array of parameters to pass the callback
		 * @return TweenLite instance
		 */
		public function addCallback(callback:Function, timeOrLabel:*, params:Array=null):TweenLite {
			var cb:TweenLite = new TweenLite(callback, 0, {onComplete:callback, onCompleteParams:params, overwrite:0, immediateRender:false});
			insert(cb, timeOrLabel);
			return cb;
		}
		
		/**
		 * Removes a callback from a particular time or label. If timeOrLabel is null, all callbacks of that
		 * particular function are removed from the timeline.
		 * 
		 * @param function callback function to be removed
		 * @param timeOrLabel the time in seconds (or frames for frames-based timelines) or label from which the callback should be removed. For example, <code>myTimeline.removeCallback(myFunction, 3)</code> would remove the callback from 3-seconds into the timeline, and <code>myTimeline.removeCallback(myFunction, ""myLabel"")</code> would remove it from the ""myLabel"" label, and <code>myTimeline.removeCallback(myFunction, null)</code> would remove ALL callbacks of that function regardless of where they are on the timeline.
		 * @return true if any callbacks were successfully found and removed. false otherwise.
		 */
		public function removeCallback(callback:Function, timeOrLabel:*=null):Boolean {
			if (timeOrLabel == null) {
				return killTweensOf(callback, false);
			} else {
				if (typeof(timeOrLabel) == ""string"") {
					if (!(timeOrLabel in _labels)) {
						return false;
					}
					timeOrLabel = _labels[timeOrLabel];
				}
				var a:Array = getTweensOf(callback, false), success:Boolean;
				var i:int = a.length;
				while (--i > -1) {
					if (a[i].cachedStartTime == timeOrLabel) {
						remove(a[i] as TweenCore);
						success = true;
					}
				}
				return success;
			}
		}
		
		/**
		 * Creates a linear tween that essentially scrubs the playhead to a particular time or label and then stops. For 
		 * example, to make the TimelineMax play to the ""myLabel2"" label, simply do: <br /><br /><code>
		 * 
		 * myTimeline.tweenTo(""myLabel2""); <br /><br /></code>
		 * 
		 * If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, 
		 * just pass in a vars object with the appropriate properties. For example, to tween to the 5-second point on the 
		 * timeline and then call a function named <code>myFunction</code> and pass in a parameter that's references this 
		 * TimelineMax and use a Strong.easeOut ease, you'd do: <br /><br /><code>
		 * 
		 * myTimeline.tweenTo(5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});<br /><br /></code>
		 * 
		 * Remember, this method simply creates a TweenLite instance that tweens the <code>currentTime</code> property of your timeline. 
		 * So you can store a reference to that tween if you want, and you can kill() it anytime. Also note that <code>tweenTo()</code>
		 * does <b>NOT</b> affect the timeline's <code>reversed</code> property. So if your timeline is oriented normally
		 * (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards
		 * but the <code>reversed</code> property will <b>not</b> change to <code>true</code>. Also note that <code>tweenTo()</code>
		 * pauses the timeline immediately before tweening its <code>currentTime</code> property, and it stays paused after the tween completes.
		 * If you need to resume playback, you could always use an onComplete to call the <code>resume()</code> method.<br /><br />
		 * 
		 * If you plan to sequence multiple playhead tweens one-after-the-other, it is typically better to use 
		 * <code>tweenFromTo()</code> so that you can define the starting point and ending point, allowing the 
		 * duration to be accurately determined immediately. 
		 * 
		 * @see #tweenFromTo()
		 * @param timeOrLabel The destination time in seconds (or frame if the timeline is frames-based) or label to which the timeline should play. For example, myTimeline.tweenTo(5) would play from wherever the timeline is currently to the 5-second point whereas myTimeline.tweenTo(""myLabel"") would play to wherever ""myLabel"" is on the timeline.
		 * @param vars An optional vars object that will be passed to the TweenLite instance. This allows you to define an onComplete, ease, delay, or any other TweenLite special property. onInit is the only special property that is not available (tweenTo() sets it internally)
		 * @return TweenLite instance that handles tweening the timeline to the desired time/label.
		 */
		public function tweenTo(timeOrLabel:*, vars:Object=null):TweenLite {
			var varsCopy:Object = {ease:easeNone, overwrite:2, useFrames:this.useFrames, immediateRender:false};
			for (var p:String in vars) {
				varsCopy[p] = vars[p];
			}
			varsCopy.onInit = onInitTweenTo;
			varsCopy.onInitParams = [null, this, NaN];
			varsCopy.currentTime = parseTimeOrLabel(timeOrLabel);
			var tl:TweenLite = new TweenLite(this, (Math.abs(Number(varsCopy.currentTime) - this.cachedTime) / this.cachedTimeScale) || 0.001, varsCopy);
			tl.vars.onInitParams[0] = tl;
			return tl;
		}
		
		/**
		 * Creates a linear tween that essentially scrubs the playhead from a particular time or label to another 
		 * time or label and then stops. If you plan to sequence multiple playhead tweens one-after-the-other, 
		 * <code>tweenFromTo()</code> is better to use than <code>tweenTo()</code> because it allows the duration 
		 * to be determined immediately, ensuring that subsequent tweens that are appended to a sequence are 
		 * positioned appropriately. For example, to make the TimelineMax play from the label ""myLabel1"" to the ""myLabel2"" 
		 * label, and then from ""myLabel2"" back to the beginning (a time of 0), simply do: <br /><br /><code>
		 * 
		 * var playheadTweens:TimelineMax = new TimelineMax(); <br />
		 * playheadTweens.append( myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"") );<br />
		 * playheadTweens.append( myTimeline.tweenFromTo(""myLabel2"", 0); <br /><br /></code>
		 * 
		 * If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, 
		 * just pass in a vars object with the appropriate properties. For example, to tween from the start (0) to the 
		 * 5-second point on the timeline and then call a function named <code>myFunction</code> and pass in a parameter 
		 * that's references this TimelineMax and use a Strong.easeOut ease, you'd do: <br /><br /><code>
		 * 
		 * myTimeline.tweenFromTo(0, 5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});<br /><br /></code>
		 * 
		 * Remember, this method simply creates a TweenLite instance that tweens the <code>currentTime</code> property of your timeline. 
		 * So you can store a reference to that tween if you want, and you can <code>kill()</code> it anytime. Also note that <code>tweenFromTo()</code>
		 * does <b>NOT</b> affect the timeline's <code>reversed</code> property. So if your timeline is oriented normally
		 * (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards
		 * but the <code>reversed</code> property will <b>not</b> change to <code>true</code>. Also note that <code>tweenFromTo()</code>
		 * pauses the timeline immediately before tweening its <code>currentTime</code> property, and it stays paused after the tween completes.
		 * If you need to resume playback, you could always use an onComplete to call the <code>resume()</code> method.
		 * 
		 * @see #tweenTo()
		 * @param fromTimeOrLabel The beginning time in seconds (or frame if the timeline is frames-based) or label from which the timeline should play. For example, <code>myTimeline.tweenTo(0, 5)</code> would play from 0 (the beginning) to the 5-second point whereas <code>myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"")</code> would play from ""myLabel1"" to ""myLabel2"".
		 * @param toTimeOrLabel The destination time in seconds (or frame if the timeline is frames-based) or label to which the timeline should play. For example, <code>myTimeline.tweenTo(0, 5)</code> would play from 0 (the beginning) to the 5-second point whereas <code>myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"")</code> would play from ""myLabel1"" to ""myLabel2"".
		 * @param vars An optional vars object that will be passed to the TweenLite instance. This allows you to define an onComplete, ease, delay, or any other TweenLite special property. onInit is the only special property that is not available (<code>tweenFromTo()</code> sets it internally)
		 * @return TweenLite instance that handles tweening the timeline between the desired times/labels.
		 */
		public function tweenFromTo(fromTimeOrLabel:*, toTimeOrLabel:*, vars:Object=null):TweenLite {
			var tl:TweenLite = tweenTo(toTimeOrLabel, vars);
			tl.vars.onInitParams[2] = parseTimeOrLabel(fromTimeOrLabel);
			tl.duration = Math.abs(Number(tl.vars.currentTime) - tl.vars.onInitParams[2]) / this.cachedTimeScale;
			return tl;
		}
		
		/** @private **/
		private static function onInitTweenTo(tween:TweenLite, timeline:TimelineMax, fromTime:Number):void {
			timeline.paused = true;
			if (!isNaN(fromTime)) {
				timeline.currentTime = fromTime;
			}
			if (tween.vars.currentTime != timeline.currentTime) { //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all.
				tween.duration = Math.abs(Number(tween.vars.currentTime) - timeline.currentTime) / timeline.cachedTimeScale;
			}
		}
		
		/** @private **/
		private static function easeNone(t:Number, b:Number, c:Number, d:Number):Number {
			return t / d;
		}
		
		
		/** @private **/
		override public function renderTime(time:Number, suppressEvents:Boolean=false, force:Boolean=false):void {
			if (this.gc) {
				this.setEnabled(true, false);
			} else if (!this.active && !this.cachedPaused) {
				this.active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done.
			}
			var totalDur:Number = (this.cacheIsDirty) ? this.totalDuration : this.cachedTotalDuration, prevTime:Number = this.cachedTime, prevTotalTime:Number = this.cachedTotalTime, prevStart:Number = this.cachedStartTime, prevTimeScale:Number = this.cachedTimeScale, tween:TweenCore, isComplete:Boolean, rendered:Boolean, repeated:Boolean, next:TweenCore, dur:Number, prevPaused:Boolean = this.cachedPaused;
			if (time >= totalDur) {
				if (_rawPrevTime <= totalDur && _rawPrevTime != time) {
					this.cachedTotalTime = totalDur;
					if (!this.cachedReversed && this.yoyo && _repeat % 2 != 0) {
						this.cachedTime = 0;
						forceChildrenToBeginning(0, suppressEvents);
					} else {
						this.cachedTime = this.cachedDuration;
						forceChildrenToEnd(this.cachedDuration, suppressEvents);
					}
					isComplete = !this.hasPausedChild();
					rendered = true;
					if (this.cachedDuration == 0 && isComplete && (time == 0 || _rawPrevTime < 0)) { //In order to accommodate zero-duration timelines, we must discern the momentum/direction of time in order to render values properly when the ""playhead"" goes past 0 in the forward direction or lands directly on it, and also when it moves past it in the backward direction (from a postitive time to a negative time).
						force = true;
					}
				}
				
			} else if (time <= 0) {
				if (time < 0) {
					this.active = false; 
					if (this.cachedDuration == 0 && _rawPrevTime >= 0) { //In order to accommodate zero-duration timelines, we must discern the momentum/direction of time in order to render values properly when the ""playhead"" goes past 0 in the forward direction or lands directly on it, and also when it moves past it in the backward direction (from a postitive time to a negative time).
						force = true;
						isComplete = true;
					}
				} else if (time == 0 && !this.initted) {
					force = true;
				}
				if (_rawPrevTime >= 0 && _rawPrevTime != time) {
					this.cachedTotalTime = 0;
					this.cachedTime = 0;
					forceChildrenToBeginning(0, suppressEvents);
					rendered = true;
					if (this.cachedReversed) {
						isComplete = true;
					}
				}
			} else {
				this.cachedTotalTime = this.cachedTime = time;
			}
			_rawPrevTime = time;
			
			if (_repeat != 0) {
				var cycleDuration:Number = this.cachedDuration + _repeatDelay;
				var prevCycles:int = _cyclesComplete;
				_cyclesComplete = (this.cachedTotalTime / cycleDuration) >> 0; //rounds result, like int()
				if (_cyclesComplete == this.cachedTotalTime / cycleDuration) {
					_cyclesComplete--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning)
				}
				if (prevCycles != _cyclesComplete) {
					repeated = true;
				}
				
				if (isComplete) {
					if (this.yoyo && _repeat % 2) {
						this.cachedTime = 0;
					}
				} else if (time > 0) {
					this.cachedTime = ((this.cachedTotalTime / cycleDuration) - _cyclesComplete) * cycleDuration; //originally this.cachedTotalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but Flash reports it as 0.79999999!)
					
					if (this.yoyo && _cyclesComplete % 2) {
						this.cachedTime = this.cachedDuration - this.cachedTime;
					} else if (this.cachedTime >= this.cachedDuration) {
						this.cachedTime = this.cachedDuration;
					}
					if (this.cachedTime < 0) {
						this.cachedTime = 0;
					}
				} else {
					_cyclesComplete = 0;
				}
				
				if (repeated && !isComplete && (this.cachedTime != prevTime || force)) {
					
					/*
					  make sure children at the end/beginning of the timeline are rendered properly. If, for example, 
					  a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which
					  would get transated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there
					  could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So 
					  we need to push the timeline to the end (and/or beginning depending on its yoyo value).
					*/
					
					var forward:Boolean = Boolean(!this.yoyo || (_cyclesComplete % 2 == 0));
					var prevForward:Boolean = Boolean(!this.yoyo || (prevCycles % 2 == 0));
					var wrap:Boolean = Boolean(forward == prevForward);
					if (prevCycles > _cyclesComplete) {
						prevForward = !prevForward;
					}
					
					if (prevForward) {
						prevTime = forceChildrenToEnd(this.cachedDuration, suppressEvents);
						if (wrap) {
							prevTime = forceChildrenToBeginning(0, true);
						}
					} else {
						prevTime = forceChildrenToBeginning(0, suppressEvents);
						if (wrap) {
							prevTime = forceChildrenToEnd(this.cachedDuration, true);
						}
					}
					rendered = false;
				}
				
			}
			
			if (this.cachedTotalTime == prevTotalTime && !force) {
				return;
			} else if (!this.initted) {
				this.initted = true;
			}
			
			if (prevTotalTime == 0 && this.cachedTotalTime != 0 && !suppressEvents) {
				if (this.vars.onStart) {
					this.vars.onStart.apply(null, this.vars.onStartParams);
				}
				if (_dispatcher) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.START));
				}
			}
			
			if (rendered) {
				//already rendered, so ignore
			} else if (this.cachedTime - prevTime > 0) {
				tween = _firstChild;
				while (tween) {
					next = tween.nextNode; //record it here because the value could change after rendering...
					if (this.cachedPaused && !prevPaused) { //in case a tween pauses the timeline when rendering
						break;
					} else if (tween.active || (!tween.cachedPaused && tween.cachedStartTime <= this.cachedTime && !tween.gc)) {
						
						if (!tween.cachedReversed) {
							tween.renderTime((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
						} else {
							dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
							tween.renderTime(dur - ((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
						}
						
					}
					
					tween = next;
				}
			} else {
				tween = _lastChild;
				while (tween) {
					next = tween.prevNode; //record it here because the value could change after rendering...
					if (this.cachedPaused && !prevPaused) { //in case a tween pauses the timeline when rendering
						break;
					} else if (tween.active || (!tween.cachedPaused && tween.cachedStartTime <= prevTime && !tween.gc)) {
						
						if (!tween.cachedReversed) {
							tween.renderTime((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
						} else {
							dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
							tween.renderTime(dur - ((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
						}
						
					} 
					
					tween = next;
				}
			}
			if (_hasUpdate && !suppressEvents) {
				this.vars.onUpdate.apply(null, this.vars.onUpdateParams);
			}
			if (_hasUpdateListener && !suppressEvents) {
				_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.UPDATE));
			}
			if (repeated && !suppressEvents) {
				if (this.vars.onRepeat) {
					this.vars.onRepeat.apply(null, this.vars.onRepeatParams);
				}
				if (_dispatcher) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.REPEAT));
				}
			}
			if (isComplete && (prevStart == this.cachedStartTime || prevTimeScale != this.cachedTimeScale) && (totalDur >= this.totalDuration || this.cachedTime == 0)) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline) or if it added more tweens to the timeline, we shouldn't run complete() because it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would have called complete() if it was necessary at the new time. The only exception is the timeScale property.
				complete(true, suppressEvents);
			}
		}
		
		/**
		 * Forces the timeline to completion.
		 * 
		 * @param skipRender to skip rendering the final state of the timeline, set skipRender to true. 
		 * @param suppressEvents If true, no events or callbacks will be triggered for this render (like onComplete, onUpdate, onReverseComplete, etc.)
		 */
		override public function complete(skipRender:Boolean=false, suppressEvents:Boolean=false):void {
			super.complete(skipRender, suppressEvents);
			if (_dispatcher && !suppressEvents) {
				if (this.cachedReversed && this.cachedTotalTime == 0 && this.cachedDuration != 0) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.REVERSE_COMPLETE));
				} else {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.COMPLETE));
				}
			}
		}
		
		/**
		 * Returns the tweens/timelines that are currently active in the timeline.
		 * 
		 * @param nested determines whether or not tweens and/or timelines that are inside nested timelines should be returned. If you only want the ""top level"" tweens/timelines, set this to false.
		 * @param tweens determines whether or not tweens (TweenLite and TweenMax instances) should be included in the results
		 * @param timelines determines whether or not timelines (TimelineLite and TimelineMax instances) should be included in the results
		 * @return an Array of active tweens/timelines
		 */
		public function getActive(nested:Boolean=true, tweens:Boolean=true, timelines:Boolean=false):Array {
			var a:Array = [], all:Array = getChildren(nested, tweens, timelines), i:int, tween:TweenCore;
			var l:int = all.length;
			var cnt:int = 0;
			for (i = 0; i < l; i += 1) {
				tween = all[i];
				//note: we cannot just check tween.active because timelines that contain paused children will continue to have ""active"" set to true even after the playhead passes their end point (technically a timeline can only be considered complete after all of its children have completed too, but paused tweens are...well...just waiting and until they're unpaused we don't know where their end point will be).
				if (!tween.cachedPaused && tween.timeline.cachedTotalTime >= tween.cachedStartTime && tween.timeline.cachedTotalTime < tween.cachedStartTime + tween.cachedTotalDuration / tween.cachedTimeScale && !OverwriteManager.getGlobalPaused(tween.timeline)) {
					a[cnt++] = all[i];
				}
			}
			return a;
		}
		
		/** @inheritDoc **/
		override public function invalidate():void {
			_repeat = (this.vars.repeat) ? Number(this.vars.repeat) : 0;
			_repeatDelay = (this.vars.repeatDelay) ? Number(this.vars.repeatDelay) : 0;
			this.yoyo = Boolean(this.vars.yoyo == true);
			if (this.vars.onCompleteListener != null || this.vars.onUpdateListener != null || this.vars.onStartListener != null || this.vars.onRepeatListener != null || this.vars.onReverseCompleteListener != null) {
				initDispatcher();
			}
			setDirtyCache(true);
			super.invalidate();
		}
		
		/**
		 * Returns the next label (if any) that occurs AFTER the time parameter. It makes no difference
		 * if the timeline is reversed. A label that is positioned exactly at the same time as the <code>time</code>
		 * parameter will be ignored. 
		 * 
		 * @param time Time after which the label is searched for. If you do not pass a time in, the currentTime will be used. 
		 * @return Name of the label that is after the time passed to getLabelAfter()
		 */
		public function getLabelAfter(time:Number=NaN):String {
			if (!time && time != 0) { //faster than isNan()
				time = this.cachedTime;
			}
			var labels:Array = getLabelsArray();
			var l:int = labels.length;
			for (var i:int = 0; i < l; i += 1) {
				if (labels[i].time > time) {
					return labels[i].name;
				}
			}
			return null;
		}
		
		/**
		 * Returns the previous label (if any) that occurs BEFORE the time parameter. It makes no difference
		 * if the timeline is reversed. A label that is positioned exactly at the same time as the <code>time</code>
		 * parameter will be ignored. 
		 * 
		 * @param time Time before which the label is searched for. If you do not pass a time in, the currentTime will be used. 
		 * @return Name of the label that is before the time passed to getLabelBefore()
		 */
		public function getLabelBefore(time:Number=NaN):String {
			if (!time && time != 0) { //faster than isNan()
				time = this.cachedTime;
			}
			var labels:Array = getLabelsArray();
			var i:int = labels.length;
			while (--i > -1) {
				if (labels[i].time < time) {
					return labels[i].name;
				}
			}
			return null;
		}
		
		/** @private Returns an Array of label objects, each with a ""time"" and ""name"" property, in the order that they occur in the timeline. **/
		protected function getLabelsArray():Array {
			var a:Array = [];
			for (var p:String in _labels) {
				a[a.length] = {time:_labels[p], name:p};
			}
			a.sortOn(""time"", Array.NUMERIC);
			return a;
		}
		

//---- EVENT DISPATCHING ----------------------------------------------------------------------------------------------------------
		
		/** @private **/
		protected function initDispatcher():void {
			if (_dispatcher == null) {
				_dispatcher = new EventDispatcher(this);
			}
			if (this.vars.onStartListener is Function) {
				_dispatcher.addEventListener(TweenEvent.START, this.vars.onStartListener, false, 0, true);
			}
			if (this.vars.onUpdateListener is Function) {
				_dispatcher.addEventListener(TweenEvent.UPDATE, this.vars.onUpdateListener, false, 0, true);
				_hasUpdateListener = true;
			}
			if (this.vars.onCompleteListener is Function) {
				_dispatcher.addEventListener(TweenEvent.COMPLETE, this.vars.onCompleteListener, false, 0, true);
			}
			if (this.vars.onRepeatListener is Function) {
				_dispatcher.addEventListener(TweenEvent.REPEAT, this.vars.onRepeatListener, false, 0, true);
			}
			if (this.vars.onReverseCompleteListener is Function) {
				_dispatcher.addEventListener(TweenEvent.REVERSE_COMPLETE, this.vars.onReverseCompleteListener, false, 0, true);
			}
		}
		/** @private **/
		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
			if (_dispatcher == null) {
				initDispatcher();
			}
			if (type == TweenEvent.UPDATE) {
				_hasUpdateListener = true;
			}
			_dispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
		}
		/** @private **/
		public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void {
			if (_dispatcher != null) {
				_dispatcher.removeEventListener(type, listener, useCapture);
			}
		}
		/** @private **/
		public function hasEventListener(type:String):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.hasEventListener(type);
		}
		/** @private **/
		public function willTrigger(type:String):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.willTrigger(type);
		}
		/** @private **/
		public function dispatchEvent(e:Event):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.dispatchEvent(e);
		}
		
		
//---- GETTERS / SETTERS -------------------------------------------------------------------------------------------------------
		
		
		
		/** 
		 * Value between 0 and 1 indicating the overall progress of the timeline according to its <code>totalDuration</code> 
 		 * where 0 is at the beginning, 0.5 is halfway finished, and 1 is finished. <code>currentProgress</code>, 
 		 * by contrast, describes the progress according to the timeline's duration which does not
 		 * include repeats and repeatDelays. For example, if a TimelineMax instance is set 
 		 * to repeat once, at the end of the first cycle <code>totalProgress</code> would only be 0.5 
		 * whereas <code>currentProgress</code> would be 1. If you tracked both properties over the course of the 
		 * tween, you'd see <code>currentProgress</code> go from 0 to 1 twice (once for each cycle) in the same
		 * time it takes the <code>totalProgress</code> property to go from 0 to 1 once.
		 **/
		public function get totalProgress():Number {
			return this.cachedTotalTime / this.totalDuration;
		}
		
		public function set totalProgress(n:Number):void {
			setTotalTime(this.totalDuration * n, false);
		}
		
		/**
		 * Duration of the timeline in seconds (or frames for frames-based timelines) including any repeats
		 * or repeatDelays. ""duration"", by contrast, does NOT include repeats and repeatDelays.
		 **/
		override public function get totalDuration():Number {
			if (this.cacheIsDirty) {
				var temp:Number = super.totalDuration; //just forces refresh
				//Instead of Infinity, we use 999999999999 so that we can accommodate reverses.
				this.cachedTotalDuration = (_repeat == -1) ? 999999999999 : this.cachedDuration * (_repeat + 1) + (_repeatDelay * _repeat);
			}
			return this.cachedTotalDuration;
		}
		
		/** @private **/
		override public function set currentTime(n:Number):void {
			if (_cyclesComplete == 0) {
				setTotalTime(n, false);
			} else if (this.yoyo && (_cyclesComplete % 2 == 1)) {
				setTotalTime((this.duration - n) + (_cyclesComplete * (this.cachedDuration + _repeatDelay)), false);
			} else {
				setTotalTime(n + (_cyclesComplete * (this.duration + _repeatDelay)), false);
			}
		}
		
		/** Number of times that the timeline should repeat; -1 repeats indefinitely. **/
		public function get repeat():int {
			return _repeat;
		}
		
		public function set repeat(n:int):void {
			_repeat = n;
			setDirtyCache(true);
		}
		
		/** Amount of time in seconds (or frames for frames-based timelines) between repeats **/
		public function get repeatDelay():Number {
			return _repeatDelay;
		}
		
		public function set repeatDelay(n:Number):void {
			_repeatDelay = n;
			setDirtyCache(true);
		}
		
		/** The closest label that is at or before the current time. **/
		public function get currentLabel():String {
			return getLabelBefore(this.cachedTime + 0.00000001);
		}
		
	}
}",12328,False,2109.8232206696284,median
"/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated January 1, 2020. Replaces all prior versions.
 *
 * Copyright (c) 2013-2020, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software
 * or otherwise create derivative works of the Spine Runtimes (collectively,
 * ""Products""), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC ""AS IS"" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

package spine {
	import spine.animation.*;
	import spine.attachments.*;
	import flash.utils.ByteArray;

	public class SkeletonJson {
		public var attachmentLoader : AttachmentLoader;
		public var scale : Number = 1;
		private var linkedMeshes : Vector.<LinkedMesh> = new Vector.<LinkedMesh>();

		public function SkeletonJson(attachmentLoader : AttachmentLoader = null) {
			this.attachmentLoader = attachmentLoader;
		}

		/** @param object A String or ByteArray. */
		public function readSkeletonData(object : *, name : String = null) : SkeletonData {
			if (object == null) throw new ArgumentError(""object cannot be null."");

			var root : Object;
			if (object is String)
				root = JSON.parse(String(object));
			else if (object is ByteArray)
				root = JSON.parse(ByteArray(object).readUTFBytes(ByteArray(object).length));
			else if (object is Object)
				root = object;
			else
				throw new ArgumentError(""object must be a String, ByteArray or Object."");

			var skeletonData : SkeletonData = new SkeletonData();
			skeletonData.name = name;

			// Skeleton.
			var skeletonMap : Object = root[""skeleton""];
			if (skeletonMap) {
				skeletonData.hash = skeletonMap[""hash""];
				skeletonData.version = skeletonMap[""spine""];
				skeletonData.x = skeletonMap[""x""] || 0;
				skeletonData.y = skeletonMap[""y""] || 0;
				skeletonData.width = skeletonMap[""width""] || 0;
				skeletonData.height = skeletonMap[""height""] || 0;
				skeletonData.fps = skeletonMap[""fps""] || 0;
				skeletonData.imagesPath = skeletonMap[""images""];
			}

			// Bones.
			var boneData : BoneData;
			for each (var boneMap : Object in root[""bones""]) {
				var parent : BoneData = null;
				var parentName : String = boneMap[""parent""];
				if (parentName) {
					parent = skeletonData.findBone(parentName);
					if (!parent) throw new Error(""Parent bone not found: "" + parentName);
				}
				boneData = new BoneData(skeletonData.bones.length, boneMap[""name""], parent);
				boneData.length = Number(boneMap[""length""] || 0) * scale;
				boneData.x = Number(boneMap[""x""] || 0) * scale;
				boneData.y = Number(boneMap[""y""] || 0) * scale;
				boneData.rotation = (boneMap[""rotation""] || 0);
				boneData.scaleX = getNumber(boneMap, ""scaleX"", 1);
				boneData.scaleY = getNumber(boneMap, ""scaleY"", 1);
				boneData.shearX = Number(boneMap[""shearX""] || 0);
				boneData.shearY = Number(boneMap[""shearY""] || 0);
				boneData.transformMode = TransformMode[boneMap[""transform""] || ""normal""];
				boneData.skinRequired = getValue(boneMap, ""skin"", false);

				color = boneMap[""color""];
				if (color) boneData.color.setFromString(color);

				skeletonData.bones.push(boneData);
			}

			// Slots.
			for each (var slotMap : Object in root[""slots""]) {
				var slotName : String = slotMap[""name""];
				var boneName : String = slotMap[""bone""];
				boneData = skeletonData.findBone(boneName);
				if (!boneData) throw new Error(""Slot bone not found: "" + boneName);
				var slotData : SlotData = new SlotData(skeletonData.slots.length, slotName, boneData);

				var color : String = slotMap[""color""];
				if (color) slotData.color.setFromString(color);

				var dark : String = slotMap[""dark""];
				if (dark) slotData.darkColor = Color.fromString(dark);

				slotData.attachmentName = slotMap[""attachment""];
				slotData.blendMode = BlendMode[slotMap[""blend""] || ""normal""];
				skeletonData.slots.push(slotData);
			}

			// IK constraints.
			for each (var constraintMap : Object in root[""ik""]) {
				var ikData : IkConstraintData = new IkConstraintData(constraintMap[""name""]);
				ikData.order = constraintMap[""order""] || 0;
				ikData.skinRequired = getValue(constraintMap, ""skin"", false);

				for each (boneName in constraintMap[""bones""]) {
					var bone : BoneData = skeletonData.findBone(boneName);
					if (!bone) throw new Error(""IK constraint bone not found: "" + boneName);
					ikData.bones.push(bone);
				}

				ikData.target = skeletonData.findBone(constraintMap[""target""]);
				if (!ikData.target) throw new Error(""Target bone not found: "" + constraintMap[""target""]);

				ikData.bendDirection = (!constraintMap.hasOwnProperty(""bendPositive"") || constraintMap[""bendPositive""]) ? 1 : -1;
				ikData.compress = getValue(constraintMap, ""compress"", false);
				ikData.stretch = getValue(constraintMap, ""stretch"", false);
				ikData.uniform = getValue(constraintMap, ""uniform"", false);
				ikData.softness = getNumber(constraintMap, ""softness"", 0) * scale;
				ikData.mix = getNumber(constraintMap, ""mix"", 1);

				skeletonData.ikConstraints.push(ikData);
			}

			// Transform constraints.
			for each (constraintMap in root[""transform""]) {
				var transformData : TransformConstraintData = new TransformConstraintData(constraintMap[""name""]);
				transformData.order = constraintMap[""order""] || 0;
				transformData.skinRequired = getValue(constraintMap, ""skin"", false);

				for each (boneName in constraintMap[""bones""]) {
					bone = skeletonData.findBone(boneName);
					if (!bone) throw new Error(""Transform constraint bone not found: "" + boneName);
					transformData.bones.push(bone);
				}

				transformData.target = skeletonData.findBone(constraintMap[""target""]);
				if (!transformData.target) throw new Error(""Target bone not found: "" + constraintMap[""target""]);

				transformData.local = getValue(constraintMap, ""local"", false);
				transformData.relative = getValue(constraintMap, ""relative"", false);

				transformData.offsetRotation = Number(constraintMap[""rotation""] || 0);
				transformData.offsetX = Number(constraintMap[""x""] || 0) * scale;
				transformData.offsetY = Number(constraintMap[""y""] || 0) * scale;
				transformData.offsetScaleX = Number(constraintMap[""scaleX""] || 0);
				transformData.offsetScaleY = Number(constraintMap[""scaleY""] || 0);
				transformData.offsetShearY = Number(constraintMap[""shearY""] || 0);

				transformData.mixRotate = getNumber(constraintMap, ""mixRotate"", 1);
				transformData.mixX = getNumber(constraintMap, ""mixX"", 1);
				transformData.mixY = getNumber(constraintMap, ""mixY"", transformData.mixX);
				transformData.mixScaleX = getNumber(constraintMap, ""mixScaleX"", 1);
				transformData.mixScaleY = getNumber(constraintMap, ""mixScaleY"", transformData.mixScaleX);
				transformData.mixShearY = getNumber(constraintMap, ""mixShearY"", 1);

				skeletonData.transformConstraints.push(transformData);
			}

			// Path constraints.
			for each (constraintMap in root[""path""]) {
				var pathData : PathConstraintData = new PathConstraintData(constraintMap[""name""]);
				pathData.order = constraintMap[""order""] || 0;
				pathData.skinRequired = getValue(constraintMap, ""skin"", false);

				for each (boneName in constraintMap[""bones""]) {
					bone = skeletonData.findBone(boneName);
					if (!bone) throw new Error(""Path constraint bone not found: "" + boneName);
					pathData.bones.push(bone);
				}

				pathData.target = skeletonData.findSlot(constraintMap[""target""]);
				if (!pathData.target) throw new Error(""Path target slot not found: "" + constraintMap[""target""]);

				pathData.positionMode = PositionMode[constraintMap[""positionMode""] || ""percent""];
				pathData.spacingMode = SpacingMode[constraintMap[""spacingMode""] || ""length""];
				pathData.rotateMode = RotateMode[constraintMap[""rotateMode""] || ""tangent""];
				pathData.offsetRotation = Number(constraintMap[""rotation""] || 0);
				pathData.position = Number(constraintMap[""position""] || 0);
				if (pathData.positionMode == PositionMode.fixed) pathData.position *= scale;
				pathData.spacing = Number(constraintMap[""spacing""] || 0);
				if (pathData.spacingMode == SpacingMode.length || pathData.spacingMode == SpacingMode.fixed) pathData.spacing *= scale;
				pathData.mixRotate = getNumber(constraintMap, ""mixRotate"", 1);
				pathData.mixX = getNumber(constraintMap, ""mixX"", 1);
				pathData.mixY = getNumber(constraintMap, ""mixY"", pathData.mixX);

				skeletonData.pathConstraints.push(pathData);
			}

			// Skins.
			var skins : Object = root[""skins""];
			for (var i : int = 0; i < skins.length; i++) {
				var ii : int;
				var skinMap : Object = skins[i];
				var skin : Skin = new Skin(skinMap[""name""]);

				if (skinMap[""bones""]) {
					for (ii = 0; ii < skinMap[""bones""].length; ii++) {
						boneData = skeletonData.findBone(skinMap[""bones""][ii]);
						if (boneData == null) throw new Error(""Skin bone not found: "" + skinMap[""bones""][ii]);
						skin.bones.push(boneData);
					}
				}

				var constraint : ConstraintData;
				if (skinMap[""ik""]) {
					for (ii = 0; ii < skinMap[""ik""].length; ii++) {
						constraint = skeletonData.findIkConstraint(skinMap[""ik""][ii]);
						if (constraint == null) throw new Error(""Skin IK constraint not found: "" + skinMap[""ik""][ii]);
						skin.constraints.push(constraint);
					}
				}

				if (skinMap[""transform""]) {
					for (ii = 0; ii < skinMap[""transform""].length; ii++) {
						constraint = skeletonData.findTransformConstraint(skinMap[""transform""][ii]);
						if (constraint == null) throw new Error(""Skin transform constraint not found: "" + skinMap[""transform""][ii]);
						skin.constraints.push(constraint);
					}
				}

				if (skinMap[""path""]) {
					for (ii = 0; ii < skinMap[""path""].length; ii++) {
						constraint = skeletonData.findPathConstraint(skinMap[""path""][ii]);
						if (constraint == null) throw new Error(""Skin path constraint not found: "" + skinMap[""path""][ii]);
						skin.constraints.push(constraint);
					}
				}

				for (slotName in skinMap.attachments) {
					var slot : SlotData = skeletonData.findSlot(slotName);
					var slotEntry : Object = skinMap.attachments[slotName];
					for (var attachmentName : String in slotEntry) {
						var attachment : Attachment = readAttachment(slotEntry[attachmentName], skin, slot.index, attachmentName, skeletonData);
						if (attachment != null)
							skin.setAttachment(slot.index, attachmentName, attachment);
					}
				}
				skeletonData.skins.push(skin);
				if (skin.name == ""default"") skeletonData.defaultSkin = skin;
			}

			// Linked meshes.
			var linkedMeshes : Vector.<LinkedMesh> = this.linkedMeshes;
			for each (var linkedMesh : LinkedMesh in linkedMeshes) {
				var parentSkin : Skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
				if (!parentSkin) throw new Error(""Skin not found: "" + linkedMesh.skin);
				var parentMesh : Attachment = parentSkin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
				if (!parentMesh) throw new Error(""Parent mesh not found: "" + linkedMesh.parent);
				linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? VertexAttachment(parentMesh) : linkedMesh.mesh;
				linkedMesh.mesh.parentMesh = MeshAttachment(parentMesh);
				linkedMesh.mesh.updateUVs();
			}
			linkedMeshes.length = 0;

			// Events.
			var events : Object = root[""events""];
			if (events) {
				for (var eventName : String in events) {
					var eventMap : Object = events[eventName];
					var eventData : EventData = new EventData(eventName);
					eventData.intValue = eventMap[""int""] || 0;
					eventData.floatValue = eventMap[""float""] || 0;
					eventData.stringValue = eventMap[""string""] || """";
					eventData.audioPath = eventMap[""audio""] || null;
					if (eventData.audioPath != null) {
						eventData.volume = eventMap[""volume""] || 1;
						eventData.balance = eventMap[""balance""] || 0;
					}
					skeletonData.events.push(eventData);
				}
			}

			// Animations.
			var animations : Object = root[""animations""];
			for (var animationName : String in animations)
				readAnimation(animations[animationName], animationName, skeletonData);

			return skeletonData;
		}

		private function readAttachment(map : Object, skin : Skin, slotIndex : int, name : String, skeletonData: SkeletonData) : Attachment {
			name = map[""name""] || name;

			var scale : Number = this.scale;
			var color : String;
			switch (AttachmentType[getValue(map, ""type"", ""region"")]) {
			case AttachmentType.region:
				var region : RegionAttachment = attachmentLoader.newRegionAttachment(skin, name, map[""path""] || name);
				if (!region) return null;
				region.path = map[""path""] || name;
				region.x = Number(map[""x""] || 0) * scale;
				region.y = Number(map[""y""] || 0) * scale;
				region.scaleX = getNumber(map, ""scaleX"", 1);
				region.scaleY = getNumber(map, ""scaleY"", 1);
				region.rotation = map[""rotation""] || 0;
				region.width = Number(map[""width""] || 0) * scale;
				region.height = Number(map[""height""] || 0) * scale;

				color = map[""color""];
				if (color) region.color.setFromString(color);

				region.updateOffset();
				return region;
			case AttachmentType.mesh:
			case AttachmentType.linkedmesh:
				var mesh : MeshAttachment = attachmentLoader.newMeshAttachment(skin, name, map[""path""] || name);
				if (!mesh) return null;
				mesh.path = map[""path""] || name;

				color = map[""color""];
				if (color) mesh.color.setFromString(color);

				mesh.width = Number(map[""width""] || 0) * scale;
				mesh.height = Number(map[""height""] || 0) * scale;
				if (map[""parent""]) {
					var inheritDeform : Boolean = getValue(map, ""deform"", true);
					linkedMeshes.push(new LinkedMesh(mesh, map[""skin""], slotIndex, map[""parent""], inheritDeform));
					return mesh;
				}
				var uvs : Vector.<Number> = getFloatArray(map, ""uvs"", 1);
				readVertices(map, mesh, uvs.length);
				mesh.triangles = getUintArray(map, ""triangles"");
				mesh.regionUVs = uvs;
				mesh.updateUVs();
				mesh.hullLength = int(map[""hull""] || 0) * 2;
				if (map[""edges""]) mesh.edges = getIntArray(map, ""edges"");
				return mesh;
			case AttachmentType.boundingbox:
				var box : BoundingBoxAttachment = attachmentLoader.newBoundingBoxAttachment(skin, name);
				if (!box) return null;
				readVertices(map, box, int(map[""vertexCount""]) << 1);
				return box;
			case AttachmentType.path:
				var path : PathAttachment = attachmentLoader.newPathAttachment(skin, name);
				if (!path) return null;
				path.closed = getValue(map, ""closed"", false);
				path.constantSpeed = getValue(map, ""constantSpeed"", true);
				var vertexCount : int = int(map[""vertexCount""]);
				readVertices(map, path, vertexCount << 1);
				var lengths : Vector.<Number> = new Vector.<Number>();
				for each (var curves : Object in map[""lengths""]) {
					lengths.push(Number(curves) * scale);
				}
				path.lengths = lengths;
				return path;
			case AttachmentType.point:
				var point : PointAttachment = attachmentLoader.newPointAttachment(skin, name);
				if (!point) return null;
				point.x = getNumber(map, ""x"", 0) * scale;
				point.y = getNumber(map, ""y"", 0) * scale;
				point.rotation = getNumber(map, ""rotation"", 0);

				color = map[""color""];
				if (color) point.color.setFromString(color);

				return point;
			case AttachmentType.clipping:
				var clip : ClippingAttachment = attachmentLoader.newClippingAttachment(skin, name);
				if (!clip) return null;
				var end : String = map[""end""];
				if (end != null) {
					var slot : SlotData = skeletonData.findSlot(end);
					if (slot == null) throw new Error(""Clipping end slot not found: "" + end);
					clip.endSlot = slot;
				}

				vertexCount = int(map[""vertexCount""]);
				readVertices(map, clip, vertexCount << 1);

				color = map[""color""];
				if (color) clip.color.setFromString(color);

				return clip;
			}
			return null;
		}

		private function readVertices(map : Object, attachment : VertexAttachment, verticesLength : int) : void {
			attachment.worldVerticesLength = verticesLength;
			var vertices : Vector.<Number> = getFloatArray(map, ""vertices"", 1);
			if (verticesLength == vertices.length) {
				if (scale != 1) {
					for (var i : int = 0, n : int = vertices.length; i < n; i++) {
						vertices[i] *= scale;
					}
				}
				attachment.vertices = vertices;
				return;
			}

			var weights : Vector.<Number> = new Vector.<Number>(verticesLength * 3 * 3);
			weights.length = 0;
			var bones : Vector.<int> = new Vector.<int>(verticesLength * 3);
			bones.length = 0;
			for (i = 0, n = vertices.length; i < n;) {
				var boneCount : int = int(vertices[i++]);
				bones.push(boneCount);
				for (var nn : int = i + boneCount * 4; i < nn; i += 4) {
					bones.push(int(vertices[i]));
					weights.push(vertices[i + 1] * scale);
					weights.push(vertices[i + 2] * scale);
					weights.push(vertices[i + 3]);
				}
			}
			attachment.bones = bones;
			attachment.vertices = weights;
		}

		private function readAnimation(map : Object, name : String, skeletonData : SkeletonData) : void {
			var scale : Number = this.scale;
			var timelines : Vector.<Timeline> = new Vector.<Timeline>();

			var slotMap : Object, slotIndex : int, slotName : String;
			var timelineMap : Array, keyMap : Object, nextMap : Object;
			var frame : int, bezier : int;
			var time : Number, time2 : Number;
			var curve : Object;
			var timelineName : String;
			var i : int, n : int, frames : int;

			// Slot timelines.
			var slots : Object = map[""slots""];
			for (slotName in slots) {
				slotMap = slots[slotName];
				slotIndex = skeletonData.findSlot(slotName).index;

				for (timelineName in slotMap) {
					timelineMap = slotMap[timelineName];
					if (!timelineMap) continue;

					frames = timelineMap.length;
					if (timelineName == ""attachment"") {
						var attachmentTimeline : AttachmentTimeline = new AttachmentTimeline(frames, slotIndex);
						for (frame = 0; frame < frames; frame++) {
							keyMap = timelineMap[frame];
							attachmentTimeline.setFrame(frame, getNumber(keyMap, ""time"", 0), keyMap.name);
						}
						timelines.push(attachmentTimeline);

					} else if (timelineName == ""rgba"") {
						var rgbaTimeline : RGBATimeline = new RGBATimeline(frames, frames << 2, slotIndex);
						keyMap = timelineMap[0];
						time = getNumber(keyMap, ""time"", 0);
						var rgba : Color = Color.fromString(keyMap.color);

						for (frame = 0, bezier = 0;; frame++) {
							rgbaTimeline.setFrame(frame, time, rgba.r, rgba.g, rgba.b, rgba.a);
							nextMap = timelineMap[frame + 1];
							if (!nextMap) {
								rgbaTimeline.shrink(bezier);
								break;
							}
							time2 = getNumber(nextMap, ""time"", 0);
							var newRgba : Color = Color.fromString(nextMap.color);
							curve = keyMap.curve;
							if (curve) {
								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 0, time, time2, rgba.r, newRgba.r, 1);
								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 1, time, time2, rgba.g, newRgba.g, 1);
								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 2, time, time2, rgba.b, newRgba.b, 1);
								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 3, time, time2, rgba.a, newRgba.a, 1);
							}
							time = time2;
							rgba = newRgba;
							keyMap = nextMap;
						}
						timelines.push(rgbaTimeline);

					} else if (timelineName == ""rgb"") {
						var rgbTimeline : RGBTimeline = new RGBTimeline(frames, frames * 3, slotIndex);
						keyMap = timelineMap[0];
						time = getNumber(keyMap, ""time"", 0);
						var rgb : Color = Color.fromString(keyMap.color);

						for (frame = 0, bezier = 0;; frame++) {
							rgbTimeline.setFrame(frame, time, rgb.r, rgb.g, rgb.b);
							nextMap = timelineMap[frame + 1];
							if (!nextMap) {
								rgbTimeline.shrink(bezier);
								break;
							}
							time2 = getNumber(nextMap, ""time"", 0);
							var newRgb : Color = Color.fromString(nextMap.color);
							curve = keyMap.curve;
							if (curve) {
								bezier = readCurve(curve, rgbTimeline, bezier, frame, 0, time, time2, rgb.r, newRgb.r, 1);
								bezier = readCurve(curve, rgbTimeline, bezier, frame, 1, time, time2, rgb.g, newRgb.g, 1);
								bezier = readCurve(curve, rgbTimeline, bezier, frame, 2, time, time2, rgb.b, newRgb.b, 1);
							}
							time = time2;
							rgb = newRgb;
							keyMap = nextMap;
						}
						timelines.push(rgbTimeline);

					} else if (timelineName == ""alpha"") {
						timelines.push(readTimeline(timelineMap, new AlphaTimeline(frames, frames, slotIndex), 0, 1));
					} else if (timelineName == ""rgba2"") {
						var rgba2Timeline : RGBA2Timeline = new RGBA2Timeline(frames, frames * 7, slotIndex);

						keyMap = timelineMap[0];
						time = getNumber(keyMap, ""time"", 0);
						var lighta : Color = Color.fromString(keyMap.light);
						var darka : Color = Color.fromString(keyMap.dark);

						for (frame = 0, bezier = 0;; frame++) {
							rgba2Timeline.setFrame(frame, time, lighta.r, lighta.g, lighta.b, lighta.a, darka.r, darka.g, darka.b);
							nextMap = timelineMap[frame + 1];
							if (!nextMap) {
								rgba2Timeline.shrink(bezier);
								break;
							}
							time2 = getNumber(nextMap, ""time"", 0);
							var newLighta : Color = Color.fromString(nextMap.light);
							var newDarka : Color = Color.fromString(nextMap.dark);
							curve = keyMap.curve;
							if (curve) {
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 0, time, time2, lighta.r, newLighta.r, 1);
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 1, time, time2, lighta.g, newLighta.g, 1);
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 2, time, time2, lighta.b, newLighta.b, 1);
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 3, time, time2, lighta.a, newLighta.a, 1);
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 4, time, time2, darka.r, newDarka.r, 1);
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 5, time, time2, darka.g, newDarka.g, 1);
								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 6, time, time2, darka.b, newDarka.b, 1);
							}
							time = time2;
							lighta = newLighta;
							darka = newDarka;
							keyMap = nextMap;
						}
						timelines.push(rgba2Timeline);

					} else if (timelineName == ""rgb2"") {
						var rgb2Timeline : RGB2Timeline = new RGB2Timeline(frames, frames * 6, slotIndex);

						keyMap = timelineMap[0];
						time = getNumber(keyMap, ""time"", 0);
						var light : Color = Color.fromString(keyMap.light);
						var dark : Color = Color.fromString(keyMap.dark);

						for (frame = 0, bezier = 0;; frame++) {
							rgb2Timeline.setFrame(frame, time, light.r, light.g, light.b, dark.r, dark.g, dark.b);
							nextMap = timelineMap[frame + 1];
							if (!nextMap) {
								rgb2Timeline.shrink(bezier);
								break;
							}
							time2 = getNumber(nextMap, ""time"", 0);
							var newLight : Color = Color.fromString(nextMap.light);
							var newDark : Color = Color.fromString(nextMap.dark);
							curve = keyMap.curve;
							if (curve) {
								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 0, time, time2, light.r, newLight.r, 1);
								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 1, time, time2, light.g, newLight.g, 1);
								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 2, time, time2, light.b, newLight.b, 1);
								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 3, time, time2, dark.r, newDark.r, 1);
								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 4, time, time2, dark.g, newDark.g, 1);
								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 5, time, time2, dark.b, newDark.b, 1);
							}
							time = time2;
							light = newLight;
							dark = newDark;
							keyMap = nextMap;
						}
						timelines.push(rgb2Timeline);

					} else
						throw new Error(""Invalid timeline type for a slot: "" + timelineName + "" ("" + slotName + "")"");
				}
			}

			// Bone timelines.
			var bones : Object = map[""bones""];
			for (var boneName : String in bones) {
				var bone : BoneData = skeletonData.findBone(boneName);
				if (!bone) throw new Error(""Bone not found: "" + boneName);
				var boneIndex : int = bone.index;
				var boneMap : Object = bones[boneName];

				for (timelineName in boneMap) {
					timelineMap = boneMap[timelineName];
					frames = timelineMap.length;
					if (frames == 0) continue;

					if (timelineName === ""rotate"") {
						timelines.push(readTimeline(timelineMap, new RotateTimeline(frames, frames, boneIndex), 0, 1));
					} else if (timelineName === ""translate"") {
						var translateTimeline : TranslateTimeline = new TranslateTimeline(frames, frames << 1, boneIndex);
						timelines.push(readTimeline2(timelineMap, translateTimeline, ""x"", ""y"", 0, scale));
					} else if (timelineName === ""translatex"") {
						var translateXTimeline : TranslateXTimeline = new TranslateXTimeline(frames, frames, boneIndex);
						timelines.push(readTimeline(timelineMap, translateXTimeline, 0, scale));
					} else if (timelineName === ""translatey"") {
						var translateYTimeline : TranslateYTimeline = new TranslateYTimeline(frames, frames, boneIndex);
						timelines.push(readTimeline(timelineMap, translateYTimeline, 0, scale));
					} else if (timelineName === ""scale"") {
						var scaleTimeline : ScaleTimeline = new ScaleTimeline(frames, frames << 1, boneIndex);
						timelines.push(readTimeline2(timelineMap, scaleTimeline, ""x"", ""y"", 1, 1));
					} else if (timelineName === ""scalex"") {
						var scaleXTimeline : ScaleXTimeline = new ScaleXTimeline(frames, frames, boneIndex);
						timelines.push(readTimeline(timelineMap, scaleXTimeline, 1, 1));
					} else if (timelineName === ""scaley"") {
						var scaleYTimeline : ScaleYTimeline = new ScaleYTimeline(frames, frames, boneIndex);
						timelines.push(readTimeline(timelineMap, scaleYTimeline, 1, 1));
					} else if (timelineName === ""shear"") {
						var shearTimeline : ShearTimeline = new ShearTimeline(frames, frames << 1, boneIndex);
						timelines.push(readTimeline2(timelineMap, shearTimeline, ""x"", ""y"", 0, 1));
					} else if (timelineName === ""shearx"") {
						var shearXTimeline : ShearXTimeline = new ShearXTimeline(frames, frames, boneIndex);
						timelines.push(readTimeline(timelineMap, shearXTimeline, 0, 1));
					} else if (timelineName === ""sheary"") {
						var shearYTimeline : ShearYTimeline = new ShearYTimeline(frames, frames, boneIndex);
						timelines.push(readTimeline(timelineMap, shearYTimeline, 0, 1));
					} else
						throw new Error(""Invalid timeline type for a bone: "" + timelineName + "" ("" + boneName + "")"");
				}
			}

			// IK constraint timelines.
			var ikMap : Object = map[""ik""];
			for (var ikConstraintName : String in ikMap) {
				timelineMap = map.ik[ikConstraintName];
				keyMap = timelineMap[0];
				if (!keyMap) continue;

				var ikIndex : int = skeletonData.ikConstraints.indexOf(skeletonData.findIkConstraint(ikConstraintName));
				var ikTimeline : IkConstraintTimeline = new IkConstraintTimeline(timelineMap.length, timelineMap.length << 1, ikIndex);

				time = getNumber(keyMap, ""time"", 0);
				var mix : Number = getNumber(keyMap, ""mix"", 1);
				var softness : Number = getNumber(keyMap, ""softness"", 0) * scale;

				for (frame = 0, bezier = 0;; frame++) {
					ikTimeline.setFrame(frame, time, mix, softness, getValue(keyMap, ""bendPositive"", true) ? 1 : -1, getValue(keyMap, ""compress"", false), getValue(keyMap, ""stretch"", false));
					nextMap = timelineMap[frame + 1];
					if (!nextMap) {
						ikTimeline.shrink(bezier);
						break;
					}

					time2 = getNumber(nextMap, ""time"", 0);
					var mix2 : Number = getNumber(nextMap, ""mix"", 1);
					var softness2 : Number = getNumber(nextMap, ""softness"", 0) * scale;
					curve = keyMap.curve;
					if (curve) {
						bezier = readCurve(curve, ikTimeline, bezier, frame, 0, time, time2, mix, mix2, 1);
						bezier = readCurve(curve, ikTimeline, bezier, frame, 1, time, time2, softness, softness2, scale);
					}

					time = time2;
					mix = mix2;
					softness = softness2;
					keyMap = nextMap;
				}
				timelines.push(ikTimeline);
			}

			// Transform constraint timelines.
			var mixRotate : Number, mixRotate2 : Number;
			var mixX : Number, mixX2 : Number;
			var mixY : Number, mixY2 : Number;
			var transformMap : Object = map[""transform""];
			for (var transformName : String in transformMap) {
				timelineMap = map.transform[transformName];
				keyMap = timelineMap[0];
				if (!keyMap) continue;

				var transformIndex : int = skeletonData.transformConstraints.indexOf(skeletonData.findTransformConstraint(transformName));
				var transformTimeline : TransformConstraintTimeline = new TransformConstraintTimeline(timelineMap.length, timelineMap.length * 6, transformIndex);

				time = getNumber(keyMap, ""time"", 0);
				mixRotate = getNumber(keyMap, ""mixRotate"", 1);
				var mixShearY : Number = getNumber(keyMap, ""mixShearY"", 1);
				mixX = getNumber(keyMap, ""mixX"", 1);
				mixY = getNumber(keyMap, ""mixY"", mixX);
				var mixScaleX : Number = getNumber(keyMap, ""mixScaleX"", 1);
				var mixScaleY : Number = getNumber(keyMap, ""mixScaleY"", mixScaleX);

				for (frame = 0, bezier = 0;; frame++) {
					transformTimeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
					nextMap = timelineMap[frame + 1];
					if (!nextMap) {
						transformTimeline.shrink(bezier);
						break;
					}

					time2 = getNumber(nextMap, ""time"", 0);
					mixRotate2 = getNumber(nextMap, ""mixRotate"", 1);
					var mixShearY2 : Number = getNumber(nextMap, ""mixShearY"", 1);
					mixX2 = getNumber(nextMap, ""mixX"", 1);
					mixY2 = getNumber(nextMap, ""mixY"", mixX2);
					var mixScaleX2 : Number = getNumber(nextMap, ""mixScaleX"", 1);
					var mixScaleY2 : Number = getNumber(nextMap, ""mixScaleY"", mixScaleX2);
					curve = keyMap.curve;
					if (curve) {
						bezier = readCurve(curve, transformTimeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
						bezier = readCurve(curve, transformTimeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
						bezier = readCurve(curve, transformTimeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
						bezier = readCurve(curve, transformTimeline, bezier, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
						bezier = readCurve(curve, transformTimeline, bezier, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
						bezier = readCurve(curve, transformTimeline, bezier, frame, 5, time, time2, mixShearY, mixShearY2, 1);
					}

					time = time2;
					mixRotate = mixRotate2;
					mixX = mixX2;
					mixY = mixY2;
					mixScaleX = mixScaleX2;
					mixScaleY = mixScaleY2;
					mixScaleX = mixScaleX2;
					keyMap = nextMap;
				}
				timelines.push(transformTimeline);
			}

			// Path constraint timelines.
			var paths : Object = map[""path""];
			for (var pathName : String in paths) {
				var index : int = skeletonData.findPathConstraintIndex(pathName);
				if (index == -1) throw new Error(""Path constraint not found: "" + pathName);
				var pathData : PathConstraintData = skeletonData.pathConstraints[index];

				var pathMap : Object = paths[pathName];
				for (timelineName in pathMap) {
					timelineMap = pathMap[timelineName];
					keyMap = timelineMap[0];
					if (!keyMap) continue;

					frames = timelineMap.length;
					if (timelineName === ""position"") {
						var positionTimeline : PathConstraintPositionTimeline = new PathConstraintPositionTimeline(frames, frames, index);
						timelines.push(readTimeline(timelineMap, positionTimeline, 0, pathData.positionMode == PositionMode.fixed ? scale : 1));
					} else if (timelineName === ""spacing"") {
						var spacingTimeline : PathConstraintSpacingTimeline = new PathConstraintSpacingTimeline(frames, frames, index);
						timelines.push(readTimeline(timelineMap, spacingTimeline, 0, pathData.spacingMode == SpacingMode.length || pathData.spacingMode == SpacingMode.fixed ? scale : 1));
					} else if (timelineName === ""mix"") {
						var mixTimeline : PathConstraintMixTimeline = new PathConstraintMixTimeline(frames, frames * 3, index);
						time = getNumber(keyMap, ""time"", 0);
						mixRotate = getNumber(keyMap, ""mixRotate"", 1);
						mixX = getNumber(keyMap, ""mixX"", 1);
						mixY = getNumber(keyMap, ""mixY"", mixX);
						for (frame = 0, bezier = 0;; frame++) {
							mixTimeline.setFrame(frame, time, mixRotate, mixX, mixY);
							nextMap = timelineMap[frame + 1];
							if (!nextMap) {
								mixTimeline.shrink(bezier);
								break;
							}
							time2 = getNumber(nextMap, ""time"", 0);
							mixRotate2 = getNumber(nextMap, ""mixRotate"", 1);
							mixX2 = getNumber(nextMap, ""mixX"", 1);
							mixY2 = getNumber(nextMap, ""mixY"", mixX2);
							curve = keyMap.curve;
							if (curve != null) {
								bezier = readCurve(curve, mixTimeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
								bezier = readCurve(curve, mixTimeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
								bezier = readCurve(curve, mixTimeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
							}
							time = time2;
							mixRotate = mixRotate2;
							mixX = mixX2;
							mixY = mixY2;
							keyMap = nextMap;
						}
						timelines.push(mixTimeline);
					}
				}
			}

			// Deform timelines.
			var deforms : Object = map[""deform""];
			for (var deformName : String in deforms) {
				var deformMap : Object = deforms[deformName];
				var skin : Skin = skeletonData.findSkin(deformName);
				if (skin == null) throw new Error(""Skin not found: "" + deformName);
				for (slotName in deformMap) {
					slotMap = deformMap[slotName];
					slotIndex = skeletonData.findSlot(slotName).index;
					if (slotIndex == -1) throw new Error(""Slot not found: "" + slotMap.name);
					for (timelineName in slotMap) {
						timelineMap = slotMap[timelineName];
						keyMap = timelineMap[0];
						if (!keyMap) continue;

						var attachment : VertexAttachment = skin.getAttachment(slotIndex, timelineName) as VertexAttachment;
						if (attachment == null) throw new Error(""Deform attachment not found: "" + timelineName);
						var weighted : Boolean = attachment.bones != null;
						var vertices : Vector.<Number> = attachment.vertices;
						var deformLength : int = weighted ? vertices.length / 3 * 2 : vertices.length;

						var deformTimeline : DeformTimeline = new DeformTimeline(timelineMap.length, timelineMap.length, slotIndex, attachment);
						time = getNumber(keyMap, ""time"", 0);
						for (frame = 0, bezier = 0;; frame++) {
							var deform : Vector.<Number>;
							var verticesValue : Object = keyMap[""vertices""];
							if (verticesValue == null)
								deform = weighted ? new Vector.<Number>(deformLength, true) : vertices;
							else {
								deform = new Vector.<Number>(deformLength, true);
								var start : int = Number(keyMap[""offset""] || 0);
								var temp : Vector.<Number> = getFloatArray(keyMap, ""vertices"", 1);
								for (i = 0; i < temp.length; i++)
									deform[start + i] = temp[i];
								if (scale != 1) {
									for (i = start, n = i + temp.length; i < n; i++)
										deform[i] *= scale;
								}
								if (!weighted) {
									for (i = 0; i < deformLength; i++)
										deform[i] += vertices[i];
								}
							}

							deformTimeline.setFrame(frame, time, deform);
							nextMap = timelineMap[frame + 1];
							if (!nextMap) {
								deformTimeline.shrink(bezier);
								break;
							}
							time2 = getNumber(nextMap, ""time"", 0);
							curve = keyMap.curve;
							if (curve) bezier = readCurve(curve, deformTimeline, bezier, frame, 0, time, time2, 0, 1, 1);
							time = time2;
							keyMap = nextMap;
						}
						timelines.push(deformTimeline);
					}
				}
			}

			// Draw order timelines.
			var drawOrders : Array = map[""drawOrder""];
			if (drawOrders) {
				var drawOrderTimeline : DrawOrderTimeline = new DrawOrderTimeline(drawOrders.length);
				var slotCount : int = skeletonData.slots.length;
				frame = 0;
				for each (var drawOrderMap : Object in drawOrders) {
					var drawOrder : Vector.<int> = null;
					var offsets : Array = drawOrderMap[""offsets""];
					if (offsets) {
						drawOrder = new Vector.<int>(slotCount, true);
						for (i = slotCount - 1; i >= 0; i--)
							drawOrder[i] = -1;
						var unchanged : Vector.<int> = new Vector.<int>(slotCount - offsets.length, true);
						var originalIndex : int = 0, unchangedIndex : int = 0;
						for each (var offsetMap : Object in offsets) {
							slotIndex = skeletonData.findSlot(offsetMap[""slot""]).index;
							if (slotIndex == -1) throw new Error(""Slot not found: "" + offsetMap[""slot""]);
							// Collect unchanged items.
							while (originalIndex != slotIndex)
								unchanged[unchangedIndex++] = originalIndex++;
							// Set changed items.
							drawOrder[originalIndex + offsetMap[""offset""]] = originalIndex++;
						}
						// Collect remaining unchanged items.
						while (originalIndex < slotCount)
							unchanged[unchangedIndex++] = originalIndex++;
						// Fill in unchanged items.
						for (i = slotCount - 1; i >= 0; i--)
							if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
					}
					drawOrderTimeline.setFrame(frame++, Number(drawOrderMap[""time""] || 0), drawOrder);
				}
				timelines.push(drawOrderTimeline);
			}

			// Event timelines.
			var eventsMap : Array = map[""events""];
			if (eventsMap) {
				var eventTimeline : EventTimeline = new EventTimeline(eventsMap.length);
				frame = 0;
				for each (var eventMap : Object in eventsMap) {
					var eventData : EventData = skeletonData.findEvent(eventMap[""name""]);
					if (!eventData) throw new Error(""Event not found: "" + eventMap[""name""]);
					var event : Event = new Event(Number(eventMap[""time""] || 0), eventData);
					event.intValue = getNumber(eventMap, ""int"", eventData.intValue);
					event.floatValue = getNumber(eventMap, ""float"", eventData.floatValue);
					event.stringValue = String(getValue(eventMap, ""string"", eventData.stringValue));
					if (eventData.audioPath != null) {
						event.volume = getNumber(eventMap, ""volume"", 1);
						event.balance = getNumber(eventMap, ""balance"", 0);
					}
					eventTimeline.setFrame(frame++, event);
				}
				timelines.push(eventTimeline);
			}

			var duration : Number = 0;
			for (i = 0, n = timelines.length; i < n; i++)
				duration = Math.max(duration, timelines[i].getDuration());

			skeletonData.animations.push(new Animation(name, timelines, duration));
		}

		static private function readTimeline(keys : Array, timeline : CurveTimeline1, defaultValue : Number, scale : Number) : CurveTimeline1 {
			var keyMap : Object = keys[0];
			var time : Number = getNumber(keyMap, ""time"", 0);
			var value : Number = getNumber(keyMap, ""value"", defaultValue) * scale;
			for (var frame : int = 0, bezier : int = 0;; frame++) {
				timeline.setFrame(frame, time, value);
				var nextMap : Object = keys[frame + 1];
				if (!nextMap) {
					timeline.shrink(bezier);
					return timeline;
				}
				var time2 : Number = getNumber(nextMap, ""time"", 0);
				var value2 : Number = getNumber(nextMap, ""value"", defaultValue) * scale;
				if (keyMap.curve) bezier = readCurve(keyMap.curve, timeline, bezier, frame, 0, time, time2, value, value2, scale);
				time = time2;
				value = value2;
				keyMap = nextMap;
			}
		}

		static private function readTimeline2(keys : Array, timeline : CurveTimeline2, name1 : String, name2 : String, defaultValue : Number, scale : Number) : CurveTimeline2 {
			var keyMap : Object = keys[0];
			var time : Number = getNumber(keyMap, ""time"", 0);
			var value1 : Number = getNumber(keyMap, name1, defaultValue) * scale;
			var value2 : Number = getNumber(keyMap, name2, defaultValue) * scale;
			for (var frame : int = 0, bezier : int = 0;; frame++) {
				timeline.setFrame(frame, time, value1, value2);
				var nextMap : Object = keys[frame + 1];
				if (!nextMap) {
					timeline.shrink(bezier);
					return timeline;
				}
				var time2 : Number = getNumber(nextMap, ""time"", 0);
				var nvalue1 : Number = getNumber(nextMap, name1, defaultValue) * scale;
				var nvalue2 : Number = getNumber(nextMap, name2, defaultValue) * scale;
				var curve : Object = keyMap.curve;
				if (curve != null) {
					bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, value1, nvalue1, scale);
					bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, value2, nvalue2, scale);
				}
				time = time2;
				value1 = nvalue1;
				value2 = nvalue2;
				keyMap = nextMap;
			}
		}

		static private function readCurve(curve : Object, timeline : CurveTimeline, bezier : int, frame : int, value : Number, time1 : Number, time2 : Number,
			value1 : Number, value2 : Number, scale : Number) : int {
			if (curve == ""stepped"") {
				timeline.setStepped(frame);
				return bezier;
			}
			var i : int = value << 2;
			var cx1 : Number = curve[i];
			var cy1 : Number = curve[i + 1] * scale;
			var cx2 : Number = curve[i + 2];
			var cy2 : Number = curve[i + 3] * scale;
			timeline.setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
			return bezier + 1;
		}

		static private function getValue(map : Object, property : String, defaultValue : Object) : Object {
			return map.hasOwnProperty(property) ? map[property] : defaultValue;
		}

		static private function getNumber(map : Object, property : String, defaultValue : Number) : Number {
			return map.hasOwnProperty(property) ? Number(map[property]) : defaultValue;
		}

		static private function getFloatArray(map : Object, name : String, scale : Number) : Vector.<Number> {
			var list : Array = map[name];
			var values : Vector.<Number> = new Vector.<Number>(list.length, true);
			var i : int = 0, n : int = list.length;
			if (scale == 1) {
				for (; i < n; i++)
					values[i] = list[i];
			} else {
				for (; i < n; i++)
					values[i] = list[i] * scale;
			}
			return values;
		}

		static private function getIntArray(map : Object, name : String) : Vector.<int> {
			var list : Array = map[name];
			var values : Vector.<int> = new Vector.<int>(list.length, true);
			for (var i : int = 0, n : int = list.length; i < n; i++)
				values[i] = int(list[i]);
			return values;
		}

		static private function getUintArray(map : Object, name : String) : Vector.<uint> {
			var list : Array = map[name];
			var values : Vector.<uint> = new Vector.<uint>(list.length, true);
			for (var i : int = 0, n : int = list.length; i < n; i++)
				values[i] = int(list[i]);
			return values;
		}
	}
}

import spine.attachments.MeshAttachment;

class LinkedMesh {
	internal var parent : String, skin : String;
	internal var slotIndex : int;
	internal var mesh : MeshAttachment;
	internal var inheritDeform : Boolean;

	public function LinkedMesh(mesh : MeshAttachment, skin : String, slotIndex : int, parent : String, inheritDeform : Boolean) {
		this.mesh = mesh;
		this.skin = skin;
		this.slotIndex = slotIndex;
		this.parent = parent;
		this.inheritDeform = inheritDeform;
	}
}
",12044,False,2403.3065043233933,median
"/*

  GraphicsTest.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD0323_OS128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD0323_OS128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1317_96X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 		// Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); 	 // Not tested
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_MAX7219_64X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_32X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_8X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_LS013B7DH03_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display


// End of constructor list


void u8g2_prepare(void) {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}

void u8g2_box_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawBox"");
  u8g2.drawBox(5,10,20,10);
  u8g2.drawBox(10+a,15,30,7);
  u8g2.drawStr( 0, 30, ""drawFrame"");
  u8g2.drawFrame(5,10+30,20,10);
  u8g2.drawFrame(10+a,15+30,30,7);
}

void u8g2_disc_circle(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawDisc"");
  u8g2.drawDisc(10,18,9);
  u8g2.drawDisc(24+a,16,7);
  u8g2.drawStr( 0, 30, ""drawCircle"");
  u8g2.drawCircle(10,18+30,9);
  u8g2.drawCircle(24+a,16+30,7);
}

void u8g2_r_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawRFrame/Box"");
  u8g2.drawRFrame(5, 10,40,30, a+1);
  u8g2.drawRBox(50, 10,25,40, a+1);
}

void u8g2_string(uint8_t a) {
  u8g2.setFontDirection(0);
  u8g2.drawStr(30+a,31, "" 0"");
  u8g2.setFontDirection(1);
  u8g2.drawStr(30,31+a, "" 90"");
  u8g2.setFontDirection(2);
  u8g2.drawStr(30-a,31, "" 180"");
  u8g2.setFontDirection(3);
  u8g2.drawStr(30,31-a, "" 270"");
}

void u8g2_line(uint8_t a) {
  u8g2.drawStr( 0, 0, ""drawLine"");
  u8g2.drawLine(7+a, 10, 40, 55);
  u8g2.drawLine(7+a*2, 10, 60, 55);
  u8g2.drawLine(7+a*3, 10, 80, 55);
  u8g2.drawLine(7+a*4, 10, 100, 55);
}

void u8g2_triangle(uint8_t a) {
  uint16_t offset = a;
  u8g2.drawStr( 0, 0, ""drawTriangle"");
  u8g2.drawTriangle(14,7, 45,30, 10,40);
  u8g2.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);
  u8g2.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);
  u8g2.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);
}

void u8g2_ascii_1() {
  char s[2] = "" "";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, ""ASCII page 1"");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 32;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_ascii_2() {
  char s[2] = "" "";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, ""ASCII page 2"");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 160;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_extra_page(uint8_t a)
{
  u8g2.drawStr( 0, 0, ""Unicode"");
  u8g2.setFont(u8g2_font_unifont_t_symbols);
  u8g2.setFontPosTop();
  u8g2.drawUTF8(0, 24, ""☀ ☁"");
  switch(a) {
    case 0:
    case 1:
    case 2:
    case 3:
      u8g2.drawUTF8(a*3, 36, ""☂"");
      break;
    case 4:
    case 5:
    case 6:
    case 7:
      u8g2.drawUTF8(a*3, 36, ""☔"");
      break;
  }
}

#define cross_width 24
#define cross_height 24
static const unsigned char cross_bits[] U8X8_PROGMEM  = {
  0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 
  0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80, 
  0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03, 
  0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, };

#define cross_fill_width 24
#define cross_fill_height 24
static const unsigned char cross_fill_bits[] U8X8_PROGMEM  = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26, 
  0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08, 
  0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01, 
  0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04, 
  0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21, 
  0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

#define cross_block_width 14
#define cross_block_height 14
static const unsigned char cross_block_bits[] U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0x01, 0x20, 0xFF, 0x3F, };

void u8g2_bitmap_overlay(uint8_t a) {
  uint8_t frame_size = 28;

  u8g2.drawStr(0, 0, ""Bitmap overlay"");

  u8g2.drawStr(0, frame_size + 12, ""Solid / transparent"");
  u8g2.setBitmapMode(false /* solid */);
  u8g2.drawFrame(0, 10, frame_size, frame_size);
  u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);

  u8g2.setBitmapMode(true /* transparent*/);
  u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);
  u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);
}

void u8g2_bitmap_modes(uint8_t transparent) {
  const uint8_t frame_size = 24;

  u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);
  u8g2.drawStr(frame_size * 0.5, 50, ""Black"");
  u8g2.drawStr(frame_size * 2, 50, ""White"");
  u8g2.drawStr(frame_size * 3.5, 50, ""XOR"");
  
  if(!transparent) {
    u8g2.setBitmapMode(false /* solid */);
    u8g2.drawStr(0, 0, ""Solid bitmap"");
  } else {
    u8g2.setBitmapMode(true /* transparent*/);
    u8g2.drawStr(0, 0, ""Transparent bitmap"");
  }
  u8g2.setDrawColor(0);// Black
  u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(1); // White
  u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(2); // XOR
  u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);
}

uint8_t draw_state = 0;

void draw(void) {
  u8g2_prepare();
  switch(draw_state >> 3) {
    case 0: u8g2_box_frame(draw_state&7); break;
    case 1: u8g2_disc_circle(draw_state&7); break;
    case 2: u8g2_r_frame(draw_state&7); break;
    case 3: u8g2_string(draw_state&7); break;
    case 4: u8g2_line(draw_state&7); break;
    case 5: u8g2_triangle(draw_state&7); break;
    case 6: u8g2_ascii_1(); break;
    case 7: u8g2_ascii_2(); break;
    case 8: u8g2_extra_page(draw_state&7); break;
    case 9: u8g2_bitmap_modes(0); break;
    case 10: u8g2_bitmap_modes(1); break;
    case 11: u8g2_bitmap_overlay(draw_state&7); break;
  }
}


void setup(void) {
  u8g2.begin();
}

void loop(void) {
  // picture loop  
  u8g2.clearBuffer();
  draw();
  u8g2.sendBuffer();
  
  // increase the state
  draw_state++;
  if ( draw_state >= 12*8 )
    draw_state = 0;

  // deley between each page
  delay(100);

}
",16207,True,3721.4632925563874,median
"/*

  UserPtr.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

  Requires -DU8X8_WITH_USER_PTR

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7528_ERC16064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7528_ERC16064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list

void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
  u8g2.setUserPtr((void *)""User Ptr Data"");
}

void loop(void) {
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_ncenR12_tr);
    u8g2.drawStr(0,24, (char *)u8g2.getUserPtr());
  } while ( u8g2.nextPage() );
  delay(1000);
}

",16301,True,5064.021205162813,median
"/*

  Weather.ino
  
  Show weather icons from open-iconic set.
  Plus demo for text scrolling.
  This example requires display height >= 64.

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif


/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add ""u8g2.setBusClock(400000);"" into setup() for speedup if possible */
//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4);  // Not tested 
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V




// End of constructor list




#define SUN	0
#define SUN_CLOUD  1
#define CLOUD 2
#define RAIN 3
#define THUNDER 4

void drawWeatherSymbol(u8g2_uint_t x, u8g2_uint_t y, uint8_t symbol)
{
  // fonts used:
  // u8g2_font_open_iconic_embedded_6x_t
  // u8g2_font_open_iconic_weather_6x_t
  // encoding values, see: https://github.com/olikraus/u8g2/wiki/fntgrpiconic
  
  switch(symbol)
  {
    case SUN:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 69);	
      break;
    case SUN_CLOUD:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 65);	
      break;
    case CLOUD:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 64);	
      break;
    case RAIN:
      u8g2.setFont(u8g2_font_open_iconic_weather_6x_t);
      u8g2.drawGlyph(x, y, 67);	
      break;
    case THUNDER:
      u8g2.setFont(u8g2_font_open_iconic_embedded_6x_t);
      u8g2.drawGlyph(x, y, 67);
      break;      
  }
}

void drawWeather(uint8_t symbol, int degree)
{
  drawWeatherSymbol(0, 48, symbol);
  u8g2.setFont(u8g2_font_logisoso32_tf);
  u8g2.setCursor(48+3, 42);
  u8g2.print(degree);
  u8g2.print(""°C"");		// requires enableUTF8Print()
}

/*
  Draw a string with specified pixel offset. 
  The offset can be negative.
  Limitation: The monochrome font with 8 pixel per glyph
*/
void drawScrollString(int16_t offset, const char *s)
{
  static char buf[36];	// should for screen with up to 256 pixel width 
  size_t len;
  size_t char_offset = 0;
  u8g2_uint_t dx = 0;
  size_t visible = 0;
  len = strlen(s);
  if ( offset < 0 )
  {
    char_offset = (-offset)/8;
    dx = offset + char_offset*8;
    if ( char_offset >= u8g2.getDisplayWidth()/8 )
      return;
    visible = u8g2.getDisplayWidth()/8-char_offset+1;
    strncpy(buf, s, visible);
    buf[visible] = '\\0';
    u8g2.setFont(u8g2_font_8x13_mf);
    u8g2.drawStr(char_offset*8-dx, 62, buf);
  }
  else
  {
    char_offset = offset / 8;
    if ( char_offset >= len )
      return;	// nothing visible
    dx = offset - char_offset*8;
    visible = len - char_offset;
    if ( visible > u8g2.getDisplayWidth()/8+1 )
      visible = u8g2.getDisplayWidth()/8+1;
    strncpy(buf, s+char_offset, visible);
    buf[visible] = '\\0';
    u8g2.setFont(u8g2_font_8x13_mf);
    u8g2.drawStr(-dx, 62, buf);
  }
  
}

void draw(const char *s, uint8_t symbol, int degree)
{
  int16_t offset = -(int16_t)u8g2.getDisplayWidth();
  int16_t len = strlen(s);
  for(;;)
  {
    u8g2.firstPage();
    do {
      drawWeather(symbol, degree);
      drawScrollString(offset, s);
    } while ( u8g2.nextPage() );
    delay(20);
    offset+=2;
    if ( offset > len*8+1 )
      break;
  }
}


void setup(void) {

  /* U8g2 Project: SSD1306 Test Board */
  //pinMode(10, OUTPUT);
  //pinMode(9, OUTPUT);
  
  //digitalWrite(10, 0);
  //digitalWrite(9, 0);		

  /* U8g2 Project: T6963 Test Board */
  //pinMode(18, OUTPUT);
  //digitalWrite(18, 1);	

  /* U8g2 Project: KS0108 Test Board */
  //pinMode(16, OUTPUT);
  //digitalWrite(16, 0);	

  /* U8g2 Project: LC7981 Test Board, connect RW to GND */
  //pinMode(17, OUTPUT);
  //digitalWrite(17, 0);	

  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
  //pinMode(6, OUTPUT);
  //digitalWrite(6, 0);	

  u8g2.begin();  
  u8g2.enableUTF8Print();
}

void loop(void) {

  draw(""What a beautiful day!"", SUN, 27);
  draw(""The sun's come out!"", SUN_CLOUD, 19);
  draw(""It's raining cats and dogs."", RAIN, 8);
  draw(""That sounds like thunder."", THUNDER, 12);
  draw(""It's stopped raining"", CLOUD, 15);
  
  
  
}

",16307,True,4657.7564774915445,median
"/**
 * VERSION: 1.671
 * DATE: 2011-08-09
 * AS3 (AS2 version is also available)
 * UPDATES AND DOCS AT: http://www.greensock.com/timelinemax/
 **/
package com.greensock {
	import com.greensock.core.*;
	import com.greensock.OverwriteManager;
	import com.greensock.events.TweenEvent;
	
	import flash.events.*;
/**
 * 	TimelineMax extends TimelineLite, offering exactly the same functionality plus useful 
 *  (but non-essential) features like AS3 event dispatching, repeat, repeatDelay, yoyo, 
 *  currentLabel, addCallback(), removeCallback(), tweenTo(), tweenFromTo(), getLabelAfter(), getLabelBefore(),
 * 	and getActive() (and probably more in the future). It is the ultimate sequencing tool. 
 *  Think of a TimelineMax instance like a virtual MovieClip timeline or a container where 
 *  you place tweens (or other timelines) over the course of time. You can:
 * 	
 * <ul>
 * 		<li> build sequences easily by adding tweens with the append(), prepend(), insert(), appendMultiple(), 
 * 			prependMultiple(), and insertMultiple() methods. Tweens can overlap as much as you want and you have 
 * 			complete control over where they get placed on the timeline.</li>
 * 
 * 		<li> add labels, play(), stop(), gotoAndPlay(), gotoAndStop(), restart(), tweenTo() and even reverse()! </li>
 * 		
 * 		<li> nest timelines within timelines as deeply as you want.</li>
 * 		
 * 		<li> set the progress of the timeline using its <code>currentProgress</code> property. For example, to skip to
 * 		  the halfway point, set <code>myTimeline.currentProgress = 0.5</code>.</li>
 * 		  
 * 		<li> tween the <code>currentTime</code>, <code>totalTime</code>, <code>currentProgress</code>, or <code>totalProgress</code> 
 * 		 property to fastforward/rewind the timeline. You could 
 * 		  even attach a slider to one of these properties to give the user the ability to drag 
 * 		  forwards/backwards through the whole timeline.</li>
 * 		  
 * 		<li> add onStart, onUpdate, onComplete, onReverseComplete, and/or onRepeat callbacks using the 
 * 		  constructor's <code>vars</code> object.</li>
 * 		
 * 		<li> speed up or slow down the entire timeline with its <code>timeScale</code> property. You can even tween
 * 		  this property to gradually speed up or slow down the timeline.</li>
 * 		  
 * 		<li> use the insertMultiple(), appendMultiple(), or prependMultiple() methods to create 
 * 			complex sequences including various alignment modes and staggering capabilities.  
 * 			Works great in conjunction with TweenMax.allTo() too. </li>
 * 		  
 * 		<li> base the timing on frames instead of seconds if you prefer. Please note, however, that
 * 		  the timeline's timing mode dictates its childrens' timing mode as well. </li>
 * 		
 * 		<li> kill the tweens of a particular object inside the timeline with killTweensOf() or get the tweens of an object
 * 		  with getTweensOf() or get all the tweens/timelines in the timeline with getChildren()</li>
 * 		  
 * 		<li> set the timeline to repeat any number of times or indefinitely. You can even set a delay
 * 		  between each repeat cycle and/or cause the repeat cycles to yoyo, appearing to reverse
 * 		  every other cycle. </li>
 * 		
 * 		<li> listen for START, UPDATE, REPEAT, REVERSE_COMPLETE, and COMPLETE events.</li>
 * 		
 * 		<li> get the active tweens in the timeline with getActive().</li>
 * 
 * 		<li> add callbacks (function calls) anywhere in the timeline that call a function of your choosing when 
 * 			the ""virtual playhead"" passes a particular spot.</li>
 * 		
 * 		<li> Get the <code>currentLabel</code> or find labels at various positions in the timeline
 * 			using getLabelAfter() and getLabelBefore()</li>
 * 	</ul>
 * 	
 * <b>EXAMPLE:</b><br /><br /><code>
 * 		
 * 		import com.greensock.~~;<br /><br />
 * 		
 * 		//create the timeline and add an onComplete call to myFunction when the timeline completes<br />
 * 		var myTimeline:TimelineMax = new TimelineMax({onComplete:myFunction});<br /><br />
 * 		
 * 		//add a tween<br />
 * 		myTimeline.append(new TweenLite(mc, 1, {x:200, y:100}));<br /><br />
 * 		
 * 		//add another tween at the end of the timeline (makes sequencing easy)<br />
 * 		myTimeline.append(new TweenLite(mc, 0.5, {alpha:0}));<br /><br />
 * 		
 * 		//repeat the entire timeline twice<br />
 * 		myTimeline.repeat = 2;<br /><br />
 * 		
 * 		//delay the repeat by 0.5 seconds each time.<br />
 * 		myTimeline.repeatDelay = 0.5;<br /><br />
 * 		
 * 		//pause the timeline (stop() works too)<br />
 * 		myTimeline.pause();<br /><br />
 * 		
 * 		//reverse it anytime...<br />
 * 		myTimeline.reverse();<br /><br />
 * 		
 * 		//Add a ""spin"" label 3-seconds into the timeline.<br />
 * 		myTimeline.addLabel(""spin"", 3);<br /><br />
 * 		
 * 		//insert a rotation tween at the ""spin"" label (you could also define the insert point as the time instead of a label)<br />
 * 		myTimeline.insert(new TweenLite(mc, 2, {rotation:""360""}), ""spin""); <br /><br />
 * 		
 * 		//go to the ""spin"" label and play the timeline from there...<br />
 * 		myTimeline.gotoAndPlay(""spin"");<br /><br />
 * 
 * 		//call myCallbackwhen the ""virtual playhead"" travels past the 1.5-second point.
 * 		myTimeline.addCallback(myCallback, 1.5);
 * 		
 * 		//add a tween to the beginning of the timeline, pushing all the other existing tweens back in time<br />
 * 		myTimeline.prepend(new TweenMax(mc, 1, {tint:0xFF0000}));<br /><br />
 * 		
 * 		//nest another TimelineMax inside your timeline...<br />
 * 		var nestedTimeline:TimelineMax = new TimelineMax();<br />
 * 		nestedTimeline.append(new TweenLite(mc2, 1, {x:200}));<br />
 * 		myTimeline.append(nestedTimeline);<br /><br /></code>
 * 		
 * 		
 * 	<code>insertMultiple()</code> and <code>appendMultiple()</code> provide some very powerful sequencing tools as well, 
 *  allowing you to add an Array of tweens/timelines and optionally align them with <code>SEQUENCE</code> or <code>START</code> 
 *  modes, and even stagger them if you want. For example, to insert 3 tweens into the timeline, aligning their start times but 
 *  staggering them by 0.2 seconds, <br /><br /><code>
 * 	
 * 		myTimeline.insertMultiple([new TweenLite(mc, 1, {y:""100""}),
 * 								   new TweenLite(mc2, 1, {x:120}),
 * 								   new TweenLite(mc3, 1, {alpha:0.5})], 
 * 								   0, 
 * 								   TweenAlign.START, 
 * 								   0.2);</code><br /><br />
 * 								   
 * 	You can use the constructor's <code>vars</code> object to do all the setup too, like:<br /><br /><code>
 * 	
 * 		var myTimeline:TimelineMax = new TimelineMax({tweens:[new TweenLite(mc1, 1, {y:""100""}), TweenMax.to(mc2, 1, {tint:0xFF0000})], align:TweenAlign.SEQUENCE, onComplete:myFunction, repeat:2, repeatDelay:1});</code><br /><br />
 * 	
 * 	If that confuses you, don't worry. Just use the <code>append()</code>, <code>insert()</code>, and <code>prepend()</code> methods to build your
 * 	sequence. But power users will likely appreciate the quick, compact way they can set up sequences now. <br /><br />
 *  
 *
 * <b>NOTES:</b>
 * <ul>
 * 	<li> TimelineMax automatically inits the OverwriteManager class to prevent unexpected overwriting behavior in sequences.
 * 	  The default mode is <code>AUTO</code>, but you can set it to whatever you want with <code>OverwriteManager.init()</code>
 * 	 (see <a href=""http://www.greensock.com/overwritemanager/"">http://www.greensock.com/overwritemanager/</a>)</li>
 * 	<li> TimelineMax adds about 4.9k to your SWF (not including OverwriteManager).</li>
 * </ul>
 * 
 * <b>Copyright 2011, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href=""http://www.greensock.com/terms_of_use.html"">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
 * 
 * @author Jack Doyle, jack@greensock.com
 **/
	public class TimelineMax extends TimelineLite implements IEventDispatcher {
		/** @private **/
		public static const version:Number = 1.671;
		
		/** @private **/
		protected var _repeat:int;
		/** @private **/
		protected var _repeatDelay:Number;
		/** @private **/
		protected var _cyclesComplete:int;
		/** @private **/
		protected var _dispatcher:EventDispatcher;
		/** @private **/
		protected var _hasUpdateListener:Boolean;
		
		/** 
		 * Works in conjunction with the repeat property, determining the behavior of each cycle; when <code>yoyo</code> is true, 
		 * the timeline will go back and forth, appearing to reverse every other cycle (this has no affect on the <code>reversed</code> property though). 
		 * So if repeat is 2 and <code>yoyo</code> is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. 
		 * But if repeat is 2 and <code>yoyo</code> is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end.  
		 **/
		 public var yoyo:Boolean;
		
		/**
		 * Constructor. <br /><br />
		 * 
		 * <b>SPECIAL PROPERTIES</b><br />
		 * The following special properties may be passed in via the constructor's vars parameter, like
		 * <code>new TimelineMax({paused:true, onComplete:myFunction, repeat:2, yoyo:true})</code> 
		 * 
		 * <ul>
		 * 	<li><b> delay : Number</b>				Amount of delay in seconds (or frames for frames-based timelines) before the timeline should begin.</li>
		 * 								
		 * 	<li><b> useFrames : Boolean</b>			If <code>useFrames</code> is set to true, the timeline's timing mode will be based on frames. 
		 * 											Otherwise, it will be based on seconds/time. NOTE: a TimelineLite's timing mode is 
		 * 											always determined by its parent timeline. </li>
		 * 
		 *  <li><b> paused : Boolean</b> 			Sets the initial paused state of the timeline (by default, timelines automatically begin playing immediately)</li>
		 * 
		 * 	<li><b> reversed : Boolean</b>			If true, the timeline will be reversed initially. This does NOT force it to the very end and start 
		 * 											playing backwards. It simply affects the orientation of the timeline, so if <code>reversed</code> is set to 
		 * 											true initially, it will appear not to play because it is already at the beginning. To cause it to
		 * 											play backwards from the end, set reversed to true and then set the <code>currentProgress</code> property to 1 immediately
		 * 											after creating the timeline.</li>
		 * 									
		 * 	<li><b> tweens : Array</b>				To immediately insert several tweens into the timeline, use the <code>tweens</code> special property
		 * 											to pass in an Array of TweenLite/TweenMax/TimelineLite/TimelineMax instances. You can use this in conjunction
		 * 											with the <code>align</code> and <code>stagger</code> special properties to set up complex sequences with minimal code.
		 * 											These values simply get passed to the <code>insertMultiple()</code> method.</li>
		 * 	
		 * 	<li><b> align : String</b>				Only used in conjunction with the <code>tweens</code> special property when multiple tweens are
		 * 											to be inserted immediately through the constructor. The value simply gets passed to the 
		 * 											<code>insertMultiple()</code> method. The default is <code>TweenAlign.NORMAL</code>. Options are:
		 * 											<ul>
		 * 												<li><b> TweenAlign.SEQUENCE:</b> aligns the tweens one-after-the-other in a sequence</li>
		 * 												<li><b> TweenAlign.START:</b> aligns the start times of all of the tweens (ignores delays)</li>
		 * 												<li><b> TweenAlign.NORMAL:</b> aligns the start times of all the tweens (honors delays)</li>
		 * 											</ul>The <code>align</code> special property does <b>not</b> force all child tweens/timelines to maintain
		 * 											relative positioning, so for example, if you use TweenAlign.SEQUENCE and then later change the duration
		 * 											of one of the nested tweens, it does <b>not</b> force all subsequent timelines to change their position
		 * 											on the timeline. The <code>align</code> special property only affects the alignment of the tweens that are
		 * 											initially placed into the timeline through the <code>tweens</code> special property of the <code>vars</code> object.</li>
		 * 										
		 * 	<li><b> stagger : Number</b>			Only used in conjunction with the <code>tweens</code> special property when multiple tweens are
		 * 											to be inserted immediately. It staggers the tweens by a set amount of time (in seconds) (or
		 * 											in frames if <code>useFrames</code> is true). For example, if the stagger value is 0.5 and the <code>align</code> 
		 * 											property is set to <code>TweenAlign.START</code>, the second tween will start 0.5 seconds after the first one 
		 * 											starts, then 0.5 seconds later the third one will start, etc. If the align property is 
		 * 											<code>TweenAlign.SEQUENCE</code>, there would be 0.5 seconds added between each tween. This value simply gets 
		 * 											passed to the <code>insertMultiple()</code> method. Default is 0.</li>
		 * 	
		 * 	<li><b> onStart : Function</b>			A function that should be called when the timeline begins (the <code>currentProgress</code> won't necessarily
		 * 											be zero when onStart is called. For example, if the timeline is created and then its <code>currentProgress</code>
		 * 											property is immediately set to 0.5 or if its <code>currentTime</code> property is set to something other than zero,
		 * 											onStart will still get fired because it is the first time the timeline is getting rendered.)</li>
		 * 	
		 * 	<li><b> onStartParams : Array</b>		An Array of parameters to pass the onStart function.</li>
		 * 	
		 * 	<li><b> onUpdate : Function</b>			A function that should be called every time the timeline's time/position is updated 
		 * 											(on every frame while the timeline is active)</li>
		 * 	
		 * 	<li><b> onUpdateParams : Array</b>		An Array of parameters to pass the onUpdate function</li>
		 * 	
		 * 	<li><b> onComplete : Function</b>		A function that should be called when the timeline has finished </li>
		 * 	
		 * 	<li><b> onCompleteParams : Array</b>	An Array of parameters to pass the onComplete function</li>
		 * 	
		 * 	<li><b> onReverseComplete : Function</b> A function that should be called when the timeline has reached its starting point again after having been reversed </li>
		 * 	
		 * 	<li><b> onReverseCompleteParams : Array</b> An Array of parameters to pass the onReverseComplete functions</li>
		 *  
		 * 	<li><b> onRepeat : Function</b>			A function that should be called every time the timeline repeats </li>
		 * 	
		 * 	<li><b> onRepeatParams : Array</b>		An Array of parameters to pass the onRepeat function</li>
		 * 	
		 * 	<li><b> autoRemoveChildren : Boolean</b> If autoRemoveChildren is set to true, as soon as child tweens/timelines complete,
		 * 											they will automatically get killed/removed. This is normally undesireable because
		 * 											it prevents going backwards in time (like if you want to reverse() or set the 
		 * 											<code>currentProgress</code> value to a lower value, etc.). It can, however, improve speed and memory
		 * 											management. TweenLite's root timelines use <code>autoRemoveChildren:true</code>.</li>
		 * 
		 * 	<li><b> repeat : int</b>				Number of times that the timeline should repeat. To repeat indefinitely, use -1.</li>
		 * 	
		 * 	<li><b> repeatDelay : Number</b>		Amount of time in seconds (or frames for frames-based timelines) between repeats.</li>
		 * 	
		 * 	<li><b> yoyo : Boolean</b> 				Works in conjunction with the repeat property, determining the behavior of each 
		 * 											cycle. When <code>yoyo</code> is true, the timeline will go back and forth, appearing to reverse 
		 * 											every other cycle (this has no affect on the <code>reversed</code> property though). So if repeat is
		 * 											2 and yoyo is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. But 
		 * 											if repeat is 2 and yoyo is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end. </li>
		 * 									
		 * 	<li><b> onStartListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent when it begins.
		 * 	  										This is the same as doing <code>myTimeline.addEventListener(TweenEvent.START, myFunction);</code></li>
		 * 	
		 * 	<li><b> onUpdateListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent every time it 
		 * 											updates values.	This is the same as doing <code>myTimeline.addEventListener(TweenEvent.UPDATE, myFunction);</code></li>
		 * 	  
		 * 	<li><b> onCompleteListener : Function</b>	A function to which the TimelineMax instance should dispatch a TweenEvent when it completes.
		 * 	  											This is the same as doing <code>myTimeline.addEventListener(TweenEvent.COMPLETE, myFunction);</code></li>
		 * 	</ul>
		 * 
		 * @param vars optionally pass in special properties like useFrames, onComplete, onCompleteParams, onUpdate, onUpdateParams, onStart, onStartParams, tweens, align, stagger, delay, autoRemoveChildren, onCompleteListener, onStartListener, onUpdateListener, repeat, repeatDelay, and/or yoyo.
		 */
		public function TimelineMax(vars:Object=null) {
			super(vars);
			_repeat = (this.vars.repeat) ? Number(this.vars.repeat) : 0;
			_repeatDelay = (this.vars.repeatDelay) ? Number(this.vars.repeatDelay) : 0;
			_cyclesComplete = 0;
			this.yoyo = Boolean(this.vars.yoyo == true);
			this.cacheIsDirty = true;
			if (this.vars.onCompleteListener != null || this.vars.onUpdateListener != null || this.vars.onStartListener != null || this.vars.onRepeatListener != null || this.vars.onReverseCompleteListener != null) {
				initDispatcher();
			}
		}
		
		/**
		 * If you want a function to be called at a particular time or label, use addCallback. When you add
		 * a callback, it is technically considered a zero-duration tween, so if you getChildren() there will be
		 * a tween returned for each callback. You can discern a callback from other tweens by the fact that
		 * their target is a function and the duration is zero. 
		 * 
		 * @param function the function to be called
		 * @param timeOrLabel the time in seconds (or frames for frames-based timelines) or label at which the callback should be inserted. For example, myTimeline.addCallback(myFunction, 3) would call myFunction() 3-seconds into the timeline, and myTimeline.addCallback(myFunction, ""myLabel"") would call it at the ""myLabel"" label.
		 * @param params an Array of parameters to pass the callback
		 * @return TweenLite instance
		 */
		public function addCallback(callback:Function, timeOrLabel:*, params:Array=null):TweenLite {
			var cb:TweenLite = new TweenLite(callback, 0, {onComplete:callback, onCompleteParams:params, overwrite:0, immediateRender:false});
			insert(cb, timeOrLabel);
			return cb;
		}
		
		/**
		 * Removes a callback from a particular time or label. If timeOrLabel is null, all callbacks of that
		 * particular function are removed from the timeline.
		 * 
		 * @param function callback function to be removed
		 * @param timeOrLabel the time in seconds (or frames for frames-based timelines) or label from which the callback should be removed. For example, <code>myTimeline.removeCallback(myFunction, 3)</code> would remove the callback from 3-seconds into the timeline, and <code>myTimeline.removeCallback(myFunction, ""myLabel"")</code> would remove it from the ""myLabel"" label, and <code>myTimeline.removeCallback(myFunction, null)</code> would remove ALL callbacks of that function regardless of where they are on the timeline.
		 * @return true if any callbacks were successfully found and removed. false otherwise.
		 */
		public function removeCallback(callback:Function, timeOrLabel:*=null):Boolean {
			if (timeOrLabel == null) {
				return killTweensOf(callback, false);
			} else {
				if (typeof(timeOrLabel) == ""string"") {
					if (!(timeOrLabel in _labels)) {
						return false;
					}
					timeOrLabel = _labels[timeOrLabel];
				}
				var a:Array = getTweensOf(callback, false), success:Boolean;
				var i:int = a.length;
				while (--i > -1) {
					if (a[i].cachedStartTime == timeOrLabel) {
						remove(a[i] as TweenCore);
						success = true;
					}
				}
				return success;
			}
		}
		
		/**
		 * Creates a linear tween that essentially scrubs the playhead to a particular time or label and then stops. For 
		 * example, to make the TimelineMax play to the ""myLabel2"" label, simply do: <br /><br /><code>
		 * 
		 * myTimeline.tweenTo(""myLabel2""); <br /><br /></code>
		 * 
		 * If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, 
		 * just pass in a vars object with the appropriate properties. For example, to tween to the 5-second point on the 
		 * timeline and then call a function named <code>myFunction</code> and pass in a parameter that's references this 
		 * TimelineMax and use a Strong.easeOut ease, you'd do: <br /><br /><code>
		 * 
		 * myTimeline.tweenTo(5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});<br /><br /></code>
		 * 
		 * Remember, this method simply creates a TweenLite instance that tweens the <code>currentTime</code> property of your timeline. 
		 * So you can store a reference to that tween if you want, and you can kill() it anytime. Also note that <code>tweenTo()</code>
		 * does <b>NOT</b> affect the timeline's <code>reversed</code> property. So if your timeline is oriented normally
		 * (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards
		 * but the <code>reversed</code> property will <b>not</b> change to <code>true</code>. Also note that <code>tweenTo()</code>
		 * pauses the timeline immediately before tweening its <code>currentTime</code> property, and it stays paused after the tween completes.
		 * If you need to resume playback, you could always use an onComplete to call the <code>resume()</code> method.<br /><br />
		 * 
		 * If you plan to sequence multiple playhead tweens one-after-the-other, it is typically better to use 
		 * <code>tweenFromTo()</code> so that you can define the starting point and ending point, allowing the 
		 * duration to be accurately determined immediately. 
		 * 
		 * @see #tweenFromTo()
		 * @param timeOrLabel The destination time in seconds (or frame if the timeline is frames-based) or label to which the timeline should play. For example, myTimeline.tweenTo(5) would play from wherever the timeline is currently to the 5-second point whereas myTimeline.tweenTo(""myLabel"") would play to wherever ""myLabel"" is on the timeline.
		 * @param vars An optional vars object that will be passed to the TweenLite instance. This allows you to define an onComplete, ease, delay, or any other TweenLite special property. onInit is the only special property that is not available (tweenTo() sets it internally)
		 * @return TweenLite instance that handles tweening the timeline to the desired time/label.
		 */
		public function tweenTo(timeOrLabel:*, vars:Object=null):TweenLite {
			var varsCopy:Object = {ease:easeNone, overwrite:2, useFrames:this.useFrames, immediateRender:false};
			for (var p:String in vars) {
				varsCopy[p] = vars[p];
			}
			varsCopy.onInit = onInitTweenTo;
			varsCopy.onInitParams = [null, this, NaN];
			varsCopy.currentTime = parseTimeOrLabel(timeOrLabel);
			var tl:TweenLite = new TweenLite(this, (Math.abs(Number(varsCopy.currentTime) - this.cachedTime) / this.cachedTimeScale) || 0.001, varsCopy);
			tl.vars.onInitParams[0] = tl;
			return tl;
		}
		
		/**
		 * Creates a linear tween that essentially scrubs the playhead from a particular time or label to another 
		 * time or label and then stops. If you plan to sequence multiple playhead tweens one-after-the-other, 
		 * <code>tweenFromTo()</code> is better to use than <code>tweenTo()</code> because it allows the duration 
		 * to be determined immediately, ensuring that subsequent tweens that are appended to a sequence are 
		 * positioned appropriately. For example, to make the TimelineMax play from the label ""myLabel1"" to the ""myLabel2"" 
		 * label, and then from ""myLabel2"" back to the beginning (a time of 0), simply do: <br /><br /><code>
		 * 
		 * var playheadTweens:TimelineMax = new TimelineMax(); <br />
		 * playheadTweens.append( myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"") );<br />
		 * playheadTweens.append( myTimeline.tweenFromTo(""myLabel2"", 0); <br /><br /></code>
		 * 
		 * If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, 
		 * just pass in a vars object with the appropriate properties. For example, to tween from the start (0) to the 
		 * 5-second point on the timeline and then call a function named <code>myFunction</code> and pass in a parameter 
		 * that's references this TimelineMax and use a Strong.easeOut ease, you'd do: <br /><br /><code>
		 * 
		 * myTimeline.tweenFromTo(0, 5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});<br /><br /></code>
		 * 
		 * Remember, this method simply creates a TweenLite instance that tweens the <code>currentTime</code> property of your timeline. 
		 * So you can store a reference to that tween if you want, and you can <code>kill()</code> it anytime. Also note that <code>tweenFromTo()</code>
		 * does <b>NOT</b> affect the timeline's <code>reversed</code> property. So if your timeline is oriented normally
		 * (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards
		 * but the <code>reversed</code> property will <b>not</b> change to <code>true</code>. Also note that <code>tweenFromTo()</code>
		 * pauses the timeline immediately before tweening its <code>currentTime</code> property, and it stays paused after the tween completes.
		 * If you need to resume playback, you could always use an onComplete to call the <code>resume()</code> method.
		 * 
		 * @see #tweenTo()
		 * @param fromTimeOrLabel The beginning time in seconds (or frame if the timeline is frames-based) or label from which the timeline should play. For example, <code>myTimeline.tweenTo(0, 5)</code> would play from 0 (the beginning) to the 5-second point whereas <code>myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"")</code> would play from ""myLabel1"" to ""myLabel2"".
		 * @param toTimeOrLabel The destination time in seconds (or frame if the timeline is frames-based) or label to which the timeline should play. For example, <code>myTimeline.tweenTo(0, 5)</code> would play from 0 (the beginning) to the 5-second point whereas <code>myTimeline.tweenFromTo(""myLabel1"", ""myLabel2"")</code> would play from ""myLabel1"" to ""myLabel2"".
		 * @param vars An optional vars object that will be passed to the TweenLite instance. This allows you to define an onComplete, ease, delay, or any other TweenLite special property. onInit is the only special property that is not available (<code>tweenFromTo()</code> sets it internally)
		 * @return TweenLite instance that handles tweening the timeline between the desired times/labels.
		 */
		public function tweenFromTo(fromTimeOrLabel:*, toTimeOrLabel:*, vars:Object=null):TweenLite {
			var tl:TweenLite = tweenTo(toTimeOrLabel, vars);
			tl.vars.onInitParams[2] = parseTimeOrLabel(fromTimeOrLabel);
			tl.duration = Math.abs(Number(tl.vars.currentTime) - tl.vars.onInitParams[2]) / this.cachedTimeScale;
			return tl;
		}
		
		/** @private **/
		private static function onInitTweenTo(tween:TweenLite, timeline:TimelineMax, fromTime:Number):void {
			timeline.paused = true;
			if (!isNaN(fromTime)) {
				timeline.currentTime = fromTime;
			}
			if (tween.vars.currentTime != timeline.currentTime) { //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all.
				tween.duration = Math.abs(Number(tween.vars.currentTime) - timeline.currentTime) / timeline.cachedTimeScale;
			}
		}
		
		/** @private **/
		private static function easeNone(t:Number, b:Number, c:Number, d:Number):Number {
			return t / d;
		}
		
		
		/** @private **/
		override public function renderTime(time:Number, suppressEvents:Boolean=false, force:Boolean=false):void {
			if (this.gc) {
				this.setEnabled(true, false);
			} else if (!this.active && !this.cachedPaused) {
				this.active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done.
			}
			var totalDur:Number = (this.cacheIsDirty) ? this.totalDuration : this.cachedTotalDuration, prevTime:Number = this.cachedTime, prevTotalTime:Number = this.cachedTotalTime, prevStart:Number = this.cachedStartTime, prevTimeScale:Number = this.cachedTimeScale, tween:TweenCore, isComplete:Boolean, rendered:Boolean, repeated:Boolean, next:TweenCore, dur:Number, prevPaused:Boolean = this.cachedPaused;
			if (time >= totalDur) {
				if (_rawPrevTime <= totalDur && _rawPrevTime != time) {
					this.cachedTotalTime = totalDur;
					if (!this.cachedReversed && this.yoyo && _repeat % 2 != 0) {
						this.cachedTime = 0;
						forceChildrenToBeginning(0, suppressEvents);
					} else {
						this.cachedTime = this.cachedDuration;
						forceChildrenToEnd(this.cachedDuration, suppressEvents);
					}
					isComplete = !this.hasPausedChild() && !this.cachedReversed;
					rendered = true;
					if (this.cachedDuration == 0 && isComplete && (time == 0 || _rawPrevTime < 0)) { //In order to accommodate zero-duration timelines, we must discern the momentum/direction of time in order to render values properly when the ""playhead"" goes past 0 in the forward direction or lands directly on it, and also when it moves past it in the backward direction (from a postitive time to a negative time).
						force = true;
					}
				}
				
			} else if (time <= 0) {
				if (time < 0) {
					this.active = false; 
					if (this.cachedDuration == 0 && _rawPrevTime >= 0) { //In order to accommodate zero-duration timelines, we must discern the momentum/direction of time in order to render values properly when the ""playhead"" goes past 0 in the forward direction or lands directly on it, and also when it moves past it in the backward direction (from a postitive time to a negative time).
						force = true;
						isComplete = true;
					}
				} else if (time == 0 && !this.initted) {
					force = true;
				}
				if (_rawPrevTime >= 0 && _rawPrevTime != time) {
					this.cachedTotalTime = 0;
					this.cachedTime = 0;
					forceChildrenToBeginning(0, suppressEvents);
					rendered = true;
					if (this.cachedReversed) {
						isComplete = true;
					}
				}
			} else {
				this.cachedTotalTime = this.cachedTime = time;
			}
			_rawPrevTime = time;
			
			if (_repeat != 0) {
				var cycleDuration:Number = this.cachedDuration + _repeatDelay;
				var prevCycles:int = _cyclesComplete;
				_cyclesComplete = (this.cachedTotalTime / cycleDuration) >> 0; //rounds result, like int()
				if (_cyclesComplete == this.cachedTotalTime / cycleDuration) {
					_cyclesComplete--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning)
				}
				if (prevCycles != _cyclesComplete) {
					repeated = true;
				}
				
				if (isComplete) {
					if (this.yoyo && _repeat % 2) {
						this.cachedTime = 0;
					}
				} else if (time > 0) {
					this.cachedTime = ((this.cachedTotalTime / cycleDuration) - _cyclesComplete) * cycleDuration; //originally this.cachedTotalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but Flash reports it as 0.79999999!)
					
					if (this.yoyo && _cyclesComplete % 2) {
						this.cachedTime = this.cachedDuration - this.cachedTime;
					} else if (this.cachedTime >= this.cachedDuration) {
						this.cachedTime = this.cachedDuration;
					}
					if (this.cachedTime < 0) {
						this.cachedTime = 0;
					}
				} else {
					_cyclesComplete = 0;
				}
				
				if (repeated && !isComplete && (this.cachedTime != prevTime || force)) {
					
					/*
					  make sure children at the end/beginning of the timeline are rendered properly. If, for example, 
					  a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which
					  would get transated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there
					  could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So 
					  we need to push the timeline to the end (and/or beginning depending on its yoyo value).
					*/
					
					var forward:Boolean = Boolean(!this.yoyo || (_cyclesComplete % 2 == 0));
					var prevForward:Boolean = Boolean(!this.yoyo || (prevCycles % 2 == 0));
					var wrap:Boolean = Boolean(forward == prevForward);
					if (prevCycles > _cyclesComplete) {
						prevForward = !prevForward;
					}
					
					if (prevForward) {
						prevTime = forceChildrenToEnd(this.cachedDuration, suppressEvents);
						if (wrap) {
							prevTime = forceChildrenToBeginning(0, true);
						}
					} else {
						prevTime = forceChildrenToBeginning(0, suppressEvents);
						if (wrap) {
							prevTime = forceChildrenToEnd(this.cachedDuration, true);
						}
					}
					rendered = false;
				}
				
			}
			
			if (this.cachedTotalTime == prevTotalTime && !force) {
				return;
			} else if (!this.initted) {
				this.initted = true;
			}
			
			if (prevTotalTime == 0 && this.cachedTotalTime != 0 && !suppressEvents) {
				if (this.vars.onStart) {
					this.vars.onStart.apply(null, this.vars.onStartParams);
				}
				if (_dispatcher) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.START));
				}
			}
			
			if (rendered) {
				//already rendered, so ignore
			} else if (this.cachedTime - prevTime > 0) {
				tween = _firstChild;
				while (tween) {
					next = tween.nextNode; //record it here because the value could change after rendering...
					if (this.cachedPaused && !prevPaused) { //in case a tween pauses the timeline when rendering
						break;
					} else if (tween.active || (!tween.cachedPaused && tween.cachedStartTime <= this.cachedTime && !tween.gc)) {
						
						if (!tween.cachedReversed) {
							tween.renderTime((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
						} else {
							dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
							tween.renderTime(dur - ((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
						}
						
					}
					
					tween = next;
				}
			} else {
				tween = _lastChild;
				while (tween) {
					next = tween.prevNode; //record it here because the value could change after rendering...
					if (this.cachedPaused && !prevPaused) { //in case a tween pauses the timeline when rendering
						break;
					} else if (tween.active || (!tween.cachedPaused && tween.cachedStartTime <= prevTime && !tween.gc)) {
						
						if (!tween.cachedReversed) {
							tween.renderTime((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
						} else {
							dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
							tween.renderTime(dur - ((this.cachedTime - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
						}
						
					} 
					
					tween = next;
				}
			}
			if (_hasUpdate && !suppressEvents) {
				this.vars.onUpdate.apply(null, this.vars.onUpdateParams);
			}
			if (_hasUpdateListener && !suppressEvents) {
				_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.UPDATE));
			}
			if (repeated && !suppressEvents) {
				if (this.vars.onRepeat) {
					this.vars.onRepeat.apply(null, this.vars.onRepeatParams);
				}
				if (_dispatcher) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.REPEAT));
				}
			}
			if (isComplete && (prevStart == this.cachedStartTime || prevTimeScale != this.cachedTimeScale) && (totalDur >= this.totalDuration || this.cachedTime == 0)) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline) or if it added more tweens to the timeline, we shouldn't run complete() because it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would have called complete() if it was necessary at the new time. The only exception is the timeScale property.
				complete(true, suppressEvents);
			}
		}
		
		/**
		 * Forces the timeline to completion.
		 * 
		 * @param skipRender to skip rendering the final state of the timeline, set skipRender to true. 
		 * @param suppressEvents If true, no events or callbacks will be triggered for this render (like onComplete, onUpdate, onReverseComplete, etc.)
		 */
		override public function complete(skipRender:Boolean=false, suppressEvents:Boolean=false):void {
			super.complete(skipRender, suppressEvents);
			if (_dispatcher && !suppressEvents) {
				if (this.cachedReversed && this.cachedTotalTime == 0 && this.cachedDuration != 0) {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.REVERSE_COMPLETE));
				} else {
					_dispatcher.dispatchEvent(new TweenEvent(TweenEvent.COMPLETE));
				}
			}
		}
		
		/**
		 * Returns the tweens/timelines that are currently active in the timeline.
		 * 
		 * @param nested determines whether or not tweens and/or timelines that are inside nested timelines should be returned. If you only want the ""top level"" tweens/timelines, set this to false.
		 * @param tweens determines whether or not tweens (TweenLite and TweenMax instances) should be included in the results
		 * @param timelines determines whether or not timelines (TimelineLite and TimelineMax instances) should be included in the results
		 * @return an Array of active tweens/timelines
		 */
		public function getActive(nested:Boolean=true, tweens:Boolean=true, timelines:Boolean=false):Array {
			var a:Array = [], all:Array = getChildren(nested, tweens, timelines), i:int, tween:TweenCore;
			var l:int = all.length;
			var cnt:int = 0;
			for (i = 0; i < l; i += 1) {
				tween = all[i];
				//note: we cannot just check tween.active because timelines that contain paused children will continue to have ""active"" set to true even after the playhead passes their end point (technically a timeline can only be considered complete after all of its children have completed too, but paused tweens are...well...just waiting and until they're unpaused we don't know where their end point will be).
				if (!tween.cachedPaused && tween.timeline.cachedTotalTime >= tween.cachedStartTime && tween.timeline.cachedTotalTime < tween.cachedStartTime + tween.cachedTotalDuration / tween.cachedTimeScale && !OverwriteManager.getGlobalPaused(tween.timeline)) {
					a[cnt++] = all[i];
				}
			}
			return a;
		}
		
		/** @inheritDoc **/
		override public function invalidate():void {
			_repeat = (this.vars.repeat) ? Number(this.vars.repeat) : 0;
			_repeatDelay = (this.vars.repeatDelay) ? Number(this.vars.repeatDelay) : 0;
			this.yoyo = Boolean(this.vars.yoyo == true);
			if (this.vars.onCompleteListener != null || this.vars.onUpdateListener != null || this.vars.onStartListener != null || this.vars.onRepeatListener != null || this.vars.onReverseCompleteListener != null) {
				initDispatcher();
			}
			setDirtyCache(true);
			super.invalidate();
		}
		
		/**
		 * Returns the next label (if any) that occurs AFTER the time parameter. It makes no difference
		 * if the timeline is reversed. A label that is positioned exactly at the same time as the <code>time</code>
		 * parameter will be ignored. 
		 * 
		 * @param time Time after which the label is searched for. If you do not pass a time in, the currentTime will be used. 
		 * @return Name of the label that is after the time passed to getLabelAfter()
		 */
		public function getLabelAfter(time:Number=NaN):String {
			if (!time && time != 0) { //faster than isNan()
				time = this.cachedTime;
			}
			var labels:Array = getLabelsArray();
			var l:int = labels.length;
			for (var i:int = 0; i < l; i += 1) {
				if (labels[i].time > time) {
					return labels[i].name;
				}
			}
			return null;
		}
		
		/**
		 * Returns the previous label (if any) that occurs BEFORE the time parameter. It makes no difference
		 * if the timeline is reversed. A label that is positioned exactly at the same time as the <code>time</code>
		 * parameter will be ignored. 
		 * 
		 * @param time Time before which the label is searched for. If you do not pass a time in, the currentTime will be used. 
		 * @return Name of the label that is before the time passed to getLabelBefore()
		 */
		public function getLabelBefore(time:Number=NaN):String {
			if (!time && time != 0) { //faster than isNan()
				time = this.cachedTime;
			}
			var labels:Array = getLabelsArray();
			var i:int = labels.length;
			while (--i > -1) {
				if (labels[i].time < time) {
					return labels[i].name;
				}
			}
			return null;
		}
		
		/** @private Returns an Array of label objects, each with a ""time"" and ""name"" property, in the order that they occur in the timeline. **/
		protected function getLabelsArray():Array {
			var a:Array = [];
			for (var p:String in _labels) {
				a[a.length] = {time:_labels[p], name:p};
			}
			a.sortOn(""time"", Array.NUMERIC);
			return a;
		}
		

//---- EVENT DISPATCHING ----------------------------------------------------------------------------------------------------------
		
		/** @private **/
		protected function initDispatcher():void {
			if (_dispatcher == null) {
				_dispatcher = new EventDispatcher(this);
			}
			if (this.vars.onStartListener is Function) {
				_dispatcher.addEventListener(TweenEvent.START, this.vars.onStartListener, false, 0, true);
			}
			if (this.vars.onUpdateListener is Function) {
				_dispatcher.addEventListener(TweenEvent.UPDATE, this.vars.onUpdateListener, false, 0, true);
				_hasUpdateListener = true;
			}
			if (this.vars.onCompleteListener is Function) {
				_dispatcher.addEventListener(TweenEvent.COMPLETE, this.vars.onCompleteListener, false, 0, true);
			}
			if (this.vars.onRepeatListener is Function) {
				_dispatcher.addEventListener(TweenEvent.REPEAT, this.vars.onRepeatListener, false, 0, true);
			}
			if (this.vars.onReverseCompleteListener is Function) {
				_dispatcher.addEventListener(TweenEvent.REVERSE_COMPLETE, this.vars.onReverseCompleteListener, false, 0, true);
			}
		}
		/** @private **/
		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
			if (_dispatcher == null) {
				initDispatcher();
			}
			if (type == TweenEvent.UPDATE) {
				_hasUpdateListener = true;
			}
			_dispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
		}
		/** @private **/
		public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void {
			if (_dispatcher != null) {
				_dispatcher.removeEventListener(type, listener, useCapture);
			}
		}
		/** @private **/
		public function hasEventListener(type:String):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.hasEventListener(type);
		}
		/** @private **/
		public function willTrigger(type:String):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.willTrigger(type);
		}
		/** @private **/
		public function dispatchEvent(e:Event):Boolean {
			return (_dispatcher == null) ? false : _dispatcher.dispatchEvent(e);
		}
		
		
//---- GETTERS / SETTERS -------------------------------------------------------------------------------------------------------
		
		
		
		/** 
		 * Value between 0 and 1 indicating the overall progress of the timeline according to its <code>totalDuration</code> 
 		 * where 0 is at the beginning, 0.5 is halfway finished, and 1 is finished. <code>currentProgress</code>, 
 		 * by contrast, describes the progress according to the timeline's duration which does not
 		 * include repeats and repeatDelays. For example, if a TimelineMax instance is set 
 		 * to repeat once, at the end of the first cycle <code>totalProgress</code> would only be 0.5 
		 * whereas <code>currentProgress</code> would be 1. If you tracked both properties over the course of the 
		 * tween, you'd see <code>currentProgress</code> go from 0 to 1 twice (once for each cycle) in the same
		 * time it takes the <code>totalProgress</code> property to go from 0 to 1 once.
		 **/
		public function get totalProgress():Number {
			return this.cachedTotalTime / this.totalDuration;
		}
		
		public function set totalProgress(n:Number):void {
			setTotalTime(this.totalDuration * n, false);
		}
		
		/**
		 * Duration of the timeline in seconds (or frames for frames-based timelines) including any repeats
		 * or repeatDelays. ""duration"", by contrast, does NOT include repeats and repeatDelays.
		 **/
		override public function get totalDuration():Number {
			if (this.cacheIsDirty) {
				var temp:Number = super.totalDuration; //just forces refresh
				//Instead of Infinity, we use 999999999999 so that we can accommodate reverses.
				this.cachedTotalDuration = (_repeat == -1) ? 999999999999 : this.cachedDuration * (_repeat + 1) + (_repeatDelay * _repeat);
			}
			return this.cachedTotalDuration;
		}
		
		/** @private **/
		override public function set currentTime(n:Number):void {
			if (_cyclesComplete == 0) {
				setTotalTime(n, false);
			} else if (this.yoyo && (_cyclesComplete % 2 == 1)) {
				setTotalTime((this.duration - n) + (_cyclesComplete * (this.cachedDuration + _repeatDelay)), false);
			} else {
				setTotalTime(n + (_cyclesComplete * (this.duration + _repeatDelay)), false);
			}
		}
		
		/** Number of times that the timeline should repeat; -1 repeats indefinitely. **/
		public function get repeat():int {
			return _repeat;
		}
		
		public function set repeat(n:int):void {
			_repeat = n;
			setDirtyCache(true);
		}
		
		/** Amount of time in seconds (or frames for frames-based timelines) between repeats **/
		public function get repeatDelay():Number {
			return _repeatDelay;
		}
		
		public function set repeatDelay(n:Number):void {
			_repeatDelay = n;
			setDirtyCache(true);
		}
		
		/** The closest label that is at or before the current time. **/
		public function get currentLabel():String {
			return getLabelBefore(this.cachedTime + 0.00000001);
		}
		
	}
}",12332,False,2086.0283445377786,median
";**********************************************************************;
;                                                                      ;
;   This file is part of ZSM4, a Z80/Z180/Z280 relocatable macro-      ;
;   assembler written in Z80 assembly.                                 ;
;   Copyright (C) 2017-2020, Hector Peraza.                            ;
;   Modified by Ladislau Szilagyi ( dec 2021 - jan 2022 )              ;                           ;                                                                      ;
;   This program is free software; you can redistribute it and/or      ;
;   modify it under the terms of the GNU General Public License as     ;
;   published by the Free Software Foundation; either version 2 of     ;
;   the License, or (at your option) any later version.                ;
;                                                                      ;
;   This program is distributed in the hope that it will be useful,    ;
;   but WITHOUT ANY WARRANTY; without even the implied warranty of     ;
;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the      ;
;   GNU General Public License for more details.                       ;
;                                                                      ;
;   You should have received a copy of the GNU General Public License  ;
;   along with this program; if not, write to the Free Software        ;
;   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.          ;
;                                                                      ;
;**********************************************************************;

*include	ZSM.INC

	GLOBAL	ID,ADDSYM

; Macro types

$MACRO	equ	1
$REPT	equ	2
$IRP	equ	3
$IRPC	equ	4

;public
	global	DEFMAC,ENDMAC,MSTORE,MDFLVL,MACLVL,DFREPT
	global	DFIRP,DFIRPC,GNRMAC,FNDMAC,EXPMAC,GETSTR
	global	MACPTR,CVTNUM,LCLNUM
;extern
	global	ID,REC,SYMPTR,NEWSYM,DSPTR,IDADR,IDBUF,IDLEN
	global	GNC,ERRFLG,PTR1,FNDOPC,EVALNEW,RELERR,OERROR
	global	VALID,BACKUP,EVMODE,WERROR,FNDREC,FNDNXT,MFREE
	global	CNV2HX,MCHECK,MACCHK,ERRQ,GNR,RADIX,SYMLUK
	global	SYMTBL,GBCOL,CNDSTK,CONDSP,CLEVEL

	psect	text

;	SUBTTL	'MACRO pseudo-operator'
;
;	Macro structure as saved in high memory:
;
;  DSPTR:
;	db	STMDEF		; type = MACRO def
;	dw	len		; length of following block:
;	db	len,'name'	;  macro name
;	db	nlocal		;  number of local variables
;	db	'body line 1',0	;  macro body, dummy params replaced by
;	db	'body line 2',0	;   80h + param number, local vars by
;	db	'body line 3',0	;    0C0h + var number
;	db	...		;
;	db	EOF		;  end of macro marker
;
;	Macros are built first on low memory (following symbol table)
;	and moved to upper memory when the final size is known.
;
;  SYMPTR:
;	db	len,'name'	; macro name (old var name)
;	db	len,'arg1'	; dummy param list, needed only for scanning
;	db	len,'arg2'	;  of macro definition body and will not be
;	db	len,'arg3'	;   copied to high mem, len has the hi-bit
;	db	len,'arg4'	;    set if it corresponds to a local var
;	db	...		;
;	db	0FFh		; end of args
;	db	nlocal		; number of local variables
;	db	'body line 1',0	; params and local variables replaced by
;	db	'body line 2',0	;  single-byte code as explained above
;	db	'body line 3',0	;
;	db	...		;
;	db	EOF		; end of macro marker
;
; Nested macros are allowed. However, nesting happens at execution time and
; not at definition time (i.e. an inner macro becomes defined only when the
; outer macro is executed). The macro generation code has to track the
; nesting level nevertheless to prevent exiting prematurely the macro
; definition mode when the ENDM of an inner macro is encountered.
;

DEFMAC:	call	ID		;get macro name (ZAS type syntax)
	call	ADDSYM		;add-it as symbol
	ld	hl,(IDADR)	; get pointer to identifier (MACRO name)
	ld	a,h
	or	l
	jp	z,OERROR	; ensure is present

	ld	a,(NEWSYM)
	or	a
	jr	nz,NEWMAC	; branch if new symbol

	; M80 allows macros to have the same name as existing symbols,
	; or even existing macros. Here we do the same.

	; Macros have priority over instruction mnemonics.

	ld	a,(hl)		; get identity char
	and	1Fh		;0Fh
	jp	z,OERROR	; error if name is invalid
	ld	c,a
	ld	b,0
	inc	bc
	ld	de,(SYMPTR)	; for code @NEWMAC
	ld	(IDADR),de
	ldir			; copy length + name

NEWMAC:	ld	hl,(IDADR)
	ld	(SYMPTR),hl	; remove new symbol from symbol table

	ld	a,(hl)		; get length+flags
	and	1Fh		;0Fh ; remove flags, leave length
	ld	(hl),a

	push	hl
	ld	(IDLEN),a
	inc	hl
	ld	de,IDBUF
	ld	c,a
	ld	b,0
	ldir
	call	FNDMAC		; is this a macro re-definition?
	jr	c,NM1		; branch if not
	ld	a,STDEL
	ld	(de),a		; else delete old macro
	ld	a,(MACLVL)
	or	a
	call	z,GBCOL		; if at safe level, call garbage collector
NM1:	ld	a,(IDLEN)
	pop	hl

	ld	c,a
	ld	b,0
	inc	bc
	inc	bc
	call	MCHECK		; make sure we have enough memory
	dec	bc
	jp	c,WERROR
	add	hl,bc
	ld	(MACPTR),hl	; set macro build pointer
	ld	(PARAMS),hl	; set pointer to parameters

	xor	a
	ld	(LCLFLG),a	; clear LOCAL flag for GETPRM

	call	GNC		; get next character
	or	a		; end of line?
	call	nz,GETPRM	; get parameters if not

	xor	a
	ld	(LCOUNT),a	; reset LOCAL variable count

	ld	hl,(MACPTR)
	ld	(hl),0FFh	; set end of args marker
	inc	hl
	ld	(MACPTR),hl

	ld	a,$MACRO
	ld	(MACTYP),a	; remember type is MACRO

INCDFL:	ld	hl,MDFLVL
	inc	(hl)		; increase macro def level
	ret	nz
	dec	(hl)
VERROR:	ld	a,'V'		; on overflow, set error flag
	ld	(ERRFLG),a
	ret
;
;	Get MACRO dummy parameters or LOCAL variables
;
GETPRM:	ld	bc,RECMAX	; ensure enough available memory
	call	MACCHK		;  (RECMAX is a bit more than enough here,
	jp	c,WERROR	;   but that will save time and some bytes)
	call	BACKUP
GP0:	call	ID		; get identifier
	ld	a,(IDLEN)
	or	a		; valid identifier?
	jr	nz,GP1		; yes -> branch
	call	OERROR		; no -> argument error
	jr	GP2
GP1:	ld	c,a
	ld	b,0
	ld	hl,IDBUF
	ld	de,(MACPTR)
	ld	a,(LCLFLG)
	or	c		; set MSB of length if LOCAL variable name
	ld	(de),a		; store length
	inc	de
	ldir
	ld	(MACPTR),de
	ld	hl,LCOUNT
	inc	(hl)		; increase LOCAL variable count
GP2:	call	GNC
	cp	','		; more params?
	jr	z,GP0		; loop if yes
	or	a		; end of line?
	ret	z		; return Z if yes
	jp	BACKUP		; else backup to scanned char and return
;
;	Store macro, called from the main thread while in macro def mode.
;
MSTORE:	ld	hl,(PTR1)
	push	hl		; save current PTR1
	call	ID		; get first identifier
	cp	':'
	jr	z,MST1		; skip if label
	cp	'&'		; test for possible param substitution
	jr	nz,MST0
	ld	hl,(PTR1)
MSKIP:	ld	a,(hl)		; if yes, ignore everything
	or	a		;  up to the next delimiter
	jr	z,MSKP1
	cp	' '
	jr	z,MSKP1
	cp	TAB
	jr	z,MSKP1
	inc	hl
	cp	':'
	jr	z,MSKP1
	jr	MSKIP
MSKP1:	ld	(PTR1),hl
	jr	MST2
MST0:	call	FNDOPC		; lookup opcode
	jr	nc,MST3		; branch if found
	jr	MST2
MST1:	call	GNC		; skip over delimiter
MST2:	call	ID		; try second identifier
	call	FNDOPC		; lookup opcode
	jp	c,MST8		; branch if not found
MST3:	ld	e,(hl)
	inc	hl
	ld	d,(hl)
	inc	hl
	ld	a,(hl)
	cp	27		; class 27? (pseudo-ops)
	jp	nz,MST8		; branch if not
	ld	a,e
	cp	24		; MACRO/REPT/IRP/IRPC?
	jp	z,MST7		; branch if yes - nested macro definition
	cp	25		; ENDM?
	jp	z,MST4		; branch if yes
	cp	27		; LOCAL?
	jp	nz,MST8		; branch if not

	; LOCAL

	ld	a,(MACTYP)
	cp	$MACRO
	jp	nz,MST8		; only MACROs can have LOCALs

	ld	a,(MDFLVL)
	dec	a
	jp	nz,MST8		; don't process it if inside a nested macro

	pop	hl		; drop saved PTR1
	ld	hl,(MACPTR)
	dec	hl
	ld	a,(hl)
	inc	a		; test for 0FFh
	ret	nz		; too late, LOCAL not allowed here

	ld	a,80h
	ld	(LCLFLG),a	; set LOCAL flag for GETPRM

	ld	(MACPTR),hl
	call	GNC		; get next character
	or	a		; end of line?
	jp	z,OERROR	; error if yes
	call	GETPRM		; else get parameter list

	ld	hl,(MACPTR)
	ld	(hl),0FFh	; set new end of args
	inc	hl
	ld	(MACPTR),hl
	ret

MST4:	ld	hl,MDFLVL
	dec	(hl)		; decrement macro level
	jp	nz,MST8

	; ENDM

	ld	a,(MACLVL)
	or	a
	call	z,GBCOL		; if at safe level, call garbage collector

	pop	hl		; drop saved PTR1
	ld	hl,(MACPTR)
	ld	(hl),EOF	; set end of macro marker
	inc	hl
	ld	(MACPTR),hl

	ld	a,(MACTYP)	; check macro type
	cp	$MACRO
	jr	nz,MST6		; branch if REPT/IRP/IRPC - execute immediately

	; end MACRO definition

	ld	de,(SYMPTR)	; begin of macro build area
MST5:	ld	a,(de)
	inc	de
	inc	a		; 0FFh marks end of param list
	jr	nz,MST5		; find begin of macro body (use CPIR?)

	ld	hl,(MACPTR)
	push	hl
	or	a
	sbc	hl,de		; obtain length
	ld	c,l
	ld	b,h
	ld	de,(DSPTR)
	pop	hl
	push	bc
	dec	hl
	dec	de
	lddr			; copy to high memory

	ld	a,(LCOUNT)
	ld	(de),a		; save number of LOCAL variables
	dec	de

	ld	hl,(SYMPTR)
	ld	a,(hl)		; get length
	ld	c,a
	ld	b,0
	inc	bc
	push	bc
	add	hl,bc
	dec	hl
	lddr			; copy name + len

	pop	hl
	pop	bc
	add	hl,bc
	inc	hl		; account for LOCAL variable count field

	ex	de,hl
	ld	(hl),d
	dec	hl
	ld	(hl),e		; set length
	dec	hl
	ld	(hl),STMDEF	; struct type = macro def
	ld	(DSPTR),hl
	ld	hl,(SYMPTR)
	ld	(hl),0		; restore end of symbol table marker
	ret

MST6:	; REPT/IRP/IRPC execution

	ld	de,(MACBGN)
	ld	hl,(MACPTR)
	push	hl
	or	a
	sbc	hl,de		; obtain length
	ld	c,l
	ld	b,h
	ld	de,(DSPTR)
	pop	hl
	push	bc
	dec	hl
	dec	de
	lddr			; copy to high memory

	pop	bc
	ex	de,hl
	xor	a
	ld	(hl),a		; clear text index
	dec	hl
	ld	(hl),a
	dec	hl
	ld	a,(CLEVEL)
	ld	(hl),a		; store current conditional level
	dec	hl
	ld	a,(MACTYP)
	ld	(hl),a		; set macro type
	dec	hl
	inc	bc
	inc	bc
	inc	bc
	inc	bc
	ld	(hl),b
	dec	hl
	ld	(hl),c		; set length
	dec	hl
	ld	(hl),STMEXP	; struct type = macro expansion
	ld	(DSPTR),hl
	ld	hl,(SYMPTR)
	ld	(hl),0		; restore end of symbol table marker
	ld	hl,MACLVL
	inc	(hl)		; start macro execution
	ret	nz
	dec	(hl)
	jp	VERROR

MST7:	call	INCDFL
MST8:	ld	a,' '
	ld	(ERRFLG),a
	pop	hl
	ld	(PTR1),hl	; restore old PTR1

	ld	bc,0
MST9:	ld	a,(hl)
	inc	hl
	inc	bc		; compute length, including trailing null
	or	a
	jr	nz,MST9

	call	MACCHK		; check for enough space
	jp	c,WERROR	; error if out of memory

	ld	hl,(PTR1)
	ld	de,(MACPTR)
	push	de
	ldir			; copy line to macro body
	ld	(MACPTR),de
	dec	hl		; point back to trailing null
	ex	(sp),hl
	ld	(PTR1),hl
	ld	a,(ERRFLG)	; save ERRFLG, as MSCAN may generate spurious
	push	af		;  errors when testing for valid identifiers
	call	MSCAN		; scan line and encode params
	pop	af
	ld	(ERRFLG),a	; restore original ERRFLG
	xor	a
	ld	(de),a		; end line with a null
	inc	de
	ld	(MACPTR),de
	pop	hl
	ld	(PTR1),hl	; restore old record pointer
	ret
;
;	MSCAN - Scan line for dummy parameters and local variables,
;	and replace them with one-byte codes.
;
;	Code for dummy parameter = 80h + param ordinal
;	Code for local variable  = C0h + label ordinal
;
MSCAN:	ld	e,l		; get dest address in DE
	ld	d,h		;  (will overwrite src contents)
S0:	ld	a,(hl)		; get char from line
	or	a
	ret	z		; if end of line, return
	cp	';'
	jr	z,S14		; branch if start of comment
	cp	27H		;'
	jr	z,S9		; branch if start of quoted string
	cp	'""'		;  (inside a string any parameters
	jr	z,S9		;   must be preceded by an ampersand)
	cp	' '
	jr	z,S1		; store blanks directly
	cp	TAB
	jr	z,S1
S1A:	call	SUBST		; test for parameter and substitute if found
	jr	S0		; loop

S1:	ld	(de),a		; store char
	inc	hl		; advance pointers
	inc	de
	jr	S0		; loop

S9:	; quoted string

	ld	(de),a		; store quote char
	inc	de
	ld	c,a
S10:	inc	hl
S11:	ld	a,(hl)		; get next char
	or	a
	ret	z		; if end of line, return 
	cp	c		; quote?
	jr	z,S1		; exit this loop if yes
	cp	'&'		; ampersand?
	jr	nz,S12		; branch if not
	push	bc
	call	SUBST		; else match parameter
	pop	bc
	jr	S11		; loop

S12:	ld	(de),a		; store char
	inc	de		; advance pointer
	jr	S10		;  and loop

S14:	; comment

	inc	hl
	cp	(hl)		; do not store comments that begin with
	ret	z		;  two semicolons
	dec	hl
S15:	ld	(de),a		; store comment, but do not perform any
	or	a		;  parameter substitutions
	ret	z
	inc	de
	inc	hl
	ld	a,(hl)
	jr	S15
;
;	SUBST - Test for dummy parameter or local variable name
;	and substitute with the corresponding value if found.
;
SUBST:	push	af
	cp	'&'		; ampersand?
	jr	nz,S5A
	inc	hl		; skip it if yes (but remember it)
S5A:	push	hl
	ld	(PTR1),hl	; remember start of possible identifier
	call	ID
	ld	a,(IDLEN)
	or	a		; valid identifier?
	jr	z,S2		; branch if not

	push	de
	ld	c,a		; C = identifier length
	ld	b,80h		; B = parameter code
	ld	hl,(PARAMS)	; HL = dummy parameter list
S5:	ld	a,(hl)		; get dummy parameter length
	inc	a		; test for 0FFh
	jr	z,S3		; parameter not found, exit loop
	dec	a
	bit	7,a		; hi-bit set?
	jr	z,S8		; branch if not
	bit	6,b		; first time?
	jr	nz,S8		; branch if not
	ld	b,0C0h		; else make B = LOCAL label code
S8:	and	7Fh		; kill hi-bit
	cp	c
	jr	nz,S4		; not same length
	push	hl
	push	bc
	inc	hl
	ld	b,a
	ld	de,IDBUF
S6:	ld	a,(de)
	cp	(hl)		; compare strings (both already in uppercase)
	jr	nz,S7		; not same
	inc	hl
	inc	de
	djnz	S6
	pop	bc
	pop	hl		; matches
	pop	de
	ld	a,b
	ld	(de),a		; store parameter code
	inc	de
	pop	hl
	pop	af
	ld	hl,(PTR1)	; point past identifier
	ret

S7:	pop	bc
	pop	hl
	ld	a,(hl)
	and	7Fh		; get length
S4:	ld	e,a
	ld	d,0
	add	hl,de
	inc	hl		; point to next parameter
	inc	b
	jr	S5		; loop to match next

S3:	pop	de		; parameter not found, restore registers
	pop	hl
	pop	af
	cp	'&'		; first char was ampersand?
	jr	nz,S3A		; branch if not
	ld	(de),a		; else restore it
	inc	de
S3A:	ld	b,0
	ldir			; copy identifier name
S3B:	ld	a,(hl)
	call	VALID		;  and any other following VALID chars
	ret	c
	ld	(de),a
	inc	hl
	inc	de
	jr	S3B

S2:	pop	hl		; not an identifier, restore registers
	pop	af
	cp	'&'		; first char was ampersand?
	jr	nz,S2A		; branch if not
	ld	(de),a		; else restore it
	inc	de
S2A:	ld	a,(hl)		; copy char
	ld	(de),a
	inc	hl
	inc	de
	ret

;	SUBTTL	'MACRO processing'
;
;	EXPMAC - Expand MACRO.
;	Called with HL pointing to macro body in dynamic area
;	(e.g. as returned by FNDMAC).
;
;	Macro expansion structure as saved in high memory:
;
;	db	STMEXP		; type = MACRO expansion
;	dw	len		; length of the following block:
;	db	$MACRO		;  macro type
;	db	clevel		;  saved conditional level
;	dw	index		;  text index
;	dw	local		;  first/base number for LOCAL variables
;	dw	macptr		;  pointer to macro def
;	db	len,'arg1'	;  arg 1
;	db	len,'arg2'	;  arg 2
;	db	...		;
;	db	0FFh		;  end of args
;
EXPMAC:	ld	bc,6
	call	MCHECK
	jp	c,WERROR
	ld	a,(hl)		; get number of LOCAL variables
	inc	hl		; point to start of macro text
	push	hl
	ld	bc,(LCLNUM)	; get LOCAL base number into BC
	ld	l,a
	ld	h,0
	add	hl,bc
	ld	(LCLNUM),hl	; save number of next LOCAL variable
	pop	de
	ld	hl,(SYMPTR)
	ld	(MACBGN),hl
	ld	(hl),c		; store base number of LOCAL labels
	inc	hl
	ld	(hl),b
	inc	hl
	ld	(hl),e		; store pointer to macro def
	inc	hl
	ld	(hl),d
	inc	hl
	ld	(MACPTR),hl
	call	GNC
	or	a
	call	nz,GETARG	; get arguments
	ld	(hl),0FFh	; end of args
	inc	hl
	ld	(MACPTR),hl
	ld	a,$MACRO
	ld	(MACTYP),a
	jp	MST6		; exit via common code
;
;	Get comma-separated list of arguments
;
GETARG:	ld	bc,RECMAX	; ensure enough available memory
	call	MACCHK		;  (RECMAX is a bit more than enough here,
	jp	c,WERROR	;   but will save some bytes and time)
	call	BACKUP
GT0:	ld	de,(MACPTR)
	push	de
	inc	de		; placeholder for length
	call	GETSTR		; get next argument
	ex	de,hl
	ld	(MACPTR),hl
	pop	de
	push	af
	or	a
	sbc	hl,de
	dec	hl
	ld	a,l
	ld	(de),a		; store length
	pop	af
	jr	c,GT1
	call	GNC
	or	a
	jr	z,GT1
	cp	','
	jr	z,GT0
GT1:	ld	hl,(MACPTR)
	ret
;
;	FNDMAC - Find MACRO
;
FNDMAC:	ld	c,STMDEF	; record type = macro def
	call	FNDREC
FNDM1:	ret	c		; not found
	push	hl
	inc	hl		; skip type
	inc	hl		;  and record length
	inc	hl
	ld	a,(IDLEN)
	cp	(hl)		; compare name length
	jr	nz,FNDM3	; branch if not same
	inc	hl
	ld	b,a
	ld	de,IDBUF
FNDM2:	ld	a,(de)
	cp	(hl)
	jr	nz,FNDM3
	inc	hl
	inc	de
	djnz	FNDM2
	pop	de		; found, HL now points past macro name
	ret			; return with CY clear
FNDM3:	pop	hl
	ld	c,STMDEF
	call	FNDNXT
	jr	FNDM1
;
;	Reading from MACRO/REPT/IRP/IRPC
;
GNRMAC:	ld	c,STMEXP
	call	FNDREC		; find top-level executing macro
	jr	nc,GNR1		; branch if found

	xor	a		; if not found (should not happen!)
	ld	(MACLVL),a	;  reset the macro execution level
	jp	GNR		;   and switch back to reading from file

GNR1:	inc	hl		; skip struct type
	inc	hl		;  and length fields
	inc	hl

	ld	a,(hl)		; get macro type
	inc	hl
	inc	hl		; skip over saved conditional level
	cp	$MACRO
	jp	z,XMACRO	; execute MACRO
	cp	$REPT
	jp	z,XREPT		; execute REPT
	cp	$IRP
	jp	z,XIRP		; execute IRP
	cp	$IRPC
	jp	z,XIRPC		; execute IRPC
	jp	OERROR		; should never happen
;
;	Read from MACRO and expand arguments
;
XMACRO:	push	hl		; save pointer
	ld	c,(hl)		; get char index
	inc	hl
	ld	b,(hl)
	inc	hl
	ld	e,(hl)		; get LOCAL base number
	inc	hl
	ld	d,(hl)
	ld	(LBASE),de
	inc	hl
	ld	e,(hl)		; get pointer to macro definition
	inc	hl
	ld	d,(hl)
	inc	hl
	ld	(ARGS),hl	; save pointer to arguments
	ex	de,hl
	add	hl,bc		; index into macro text
	ld	a,(hl)		; get char
	cp	EOF
	jp	z,XEND		; end of text = end of macro

	ld	de,REC
	ld	(PTR1),de
	ld	a,RECMAX-1
	ld	(RCOUNT),a
XM1:	ld	a,(hl)		; get char from macro text
	inc	hl
	inc	bc		; advance index
	or	a		; test for coded dummy parameter
	jp	p,XM3		; branch if not parameter
	push	hl		; else save text pointer
	push	bc
	ld	hl,(ARGS)	; get start address of argument list
	sub	80h-1		; get param number
	cp	40h+1
	jr	nc,XM8		; branch if local variable
	ld	b,a		; B = param number
XM6:	ld	a,(hl)		; get length
	inc	a		; 0FFh marks end of arguments
	jr	z,XM4		; branch if not found
	dec	a
	inc	hl		; point to string
	djnz	XM5		; count until found
	or	a
	jr	z,XM7		; if null argument
	ld	b,a
XM2:	ld	a,(hl)
	call	SAVREC		; expand argument
	inc	hl
	djnz	XM2
XM7:	pop	bc
	pop	hl		; restore text pointers
	jr	XM1		; continue with text

XM5:	ld	e,a		; get length into DE
	ld	d,0
	add	hl,de		; point to next argument
	jr	XM6		; loop

XM8:	sub	40h+1		; get label ordinal
	ld	e,a
	ld	d,0
	ld	hl,(LBASE)
	add	hl,de
	ex	de,hl
	push	de
	ld	a,'?'
	call	SAVREC		; create label of type '??nnnn'
	call	SAVREC
	pop	de
	ld	hl,(PTR1)
	ld	c,d
	call	XM9
	ld	c,e
	call	XM9
	ld	(PTR1),hl
	pop	bc
	pop	hl
	jr	XM1

XM9:	ld	a,(RCOUNT)
	sub	2
	ret	c
	ld	(RCOUNT),a
	ld	a,c
	jp	CNV2HX

XM4:	pop	bc
	pop	hl		; not found, restore text pointers
	jr	XM1		;  and loop (will expand as null string)

XM3:	call	SAVREC		; save char in REC buffer
	or	a		; end of line?
	jr	nz,XM1		; loop if not
	ld	hl,(PTR1)
	ld	(hl),a		; append null in case line was truncated
	ld	hl,REC
	ld	(PTR1),hl
	pop	hl
	ld	(hl),c		; update text index
	inc	hl
	ld	(hl),b
	ret

SAVREC:	push	hl
	ld	e,a
	ld	hl,RCOUNT
	ld	a,(hl)
	or	a		; limit reached?
	jr	z,ST1		; return if yes
	dec	a
	ld	(hl),a
	ld	hl,(PTR1)
	ld	(hl),e		; store char in buffer
	inc	hl
	ld	(PTR1),hl
ST1:	ld	a,e
	pop	hl
	ret
;
;	Read from REPT, no arguments to expand
;
XREPT:	push	hl
	ld	c,(hl)		; get char index
	inc	hl
	ld	b,(hl)
	inc	hl
	ld	e,(hl)		; get count
	inc	hl
	ld	d,(hl)
	ld	a,d
	or	e		; counter reached zero?
	jp	z,XEND		; if yes, end execution

	inc	hl
	add	hl,bc		; index into macro text
	ld	a,(hl)
	cp	EOF		; end of text?
	jr	z,XR3		; branch if yes, start next iteration

	ld	de,REC
XR1:	ld	a,(hl)		; no arg substitution for REPT
	inc	hl
	inc	bc
	ld	(de),a		; and so no need to check for REC buf overflow
	or	a
	jr	z,XR2
	inc	de
	jr	XR1

XR2:	pop	hl
	ld	(hl),c		; update text index
	inc	hl
	ld	(hl),b
	ret

XR3:	pop	hl		; next iteration
	push	hl
	xor	a
	ld	(hl),a		; reset text index
	inc	hl
	ld	(hl),a
	inc	hl
	ld	c,(hl)
	inc	hl
	ld	b,(hl)
	dec	bc		; decrement iteration counter
	ld	(hl),b
	dec	hl
	ld	(hl),c
	pop	hl
	jr	XREPT		; restart execution
;
;	Read from IRP, expand single argument
;
XIRP:	push	hl
	ld	c,(hl)		; get text index
	inc	hl
	ld	b,(hl)
	inc	hl
	ld	a,(hl)		; get argument index
	inc	hl		; point to argument list
	inc	a
XP1:	ld	e,(hl)		; get arg length
	inc	e
	jp	z,XEND		; arg list exhausted
	dec	a
	jr	z,XP2
	ld	d,0
	add	hl,de		; point to next argument
	jr	XP1

XP2:	ld	(ARGS),hl
XP3:	ld	a,(hl)
	inc	hl
	inc	a
	jr	nz,XP3		; find start of body text
	add	hl,bc		; index into macro text
	ld	a,(hl)		; get char
	cp	EOF		; end of text?
	jp	z,XP7		; branch if yes, start next iteration

	ld	de,REC
	ld	(PTR1),de
	ld	a,RECMAX-1
	ld	(RCOUNT),a
XP4:	ld	a,(hl)		; get char from macro text
	inc	hl
	inc	bc		; advance index
	or	a		; test for coded dummy parameter
	jp	p,XP5		; branch if not parameter
	push	hl
	push	bc
	ld	hl,(ARGS)	; else expand parameter
	ld	a,(hl)
	inc	a
	jr	z,XP6		; if no arguments
	dec	a
	jr	z,XP6		; if null argument
	ld	b,a
	inc	hl
XP9:	ld	a,(hl)
	call	SAVREC		; expand argument
	inc	hl
	djnz	XP9
XP6:	pop	bc
	pop	hl
	jr	XP4
XP5:	call	SAVREC		; save char in REC buffer
	or	a		; end of line?
	jr	nz,XP4		; loop if not
	ld	hl,(PTR1)
	ld	(hl),a		; append null in case line was truncated
	ld	hl,REC
	ld	(PTR1),hl
	pop	hl
	ld	(hl),c		; update text index
	inc	hl
	ld	(hl),b
	ret

XP7:	pop	hl		; next iteration
	push	hl
	xor	a
	ld	(hl),a		; reset text index
	inc	hl
	ld	(hl),a
	inc	hl
	inc	(hl)		; advance arg index
	pop	hl
	jr	XIRP		; restart execution
;
;	Read from IRPC, expand single argument
;
XIRPC:	push	hl		; save pointer
	ld	c,(hl)		; get text index
	inc	hl
	ld	b,(hl)
	inc	hl
	ld	a,(hl)		; get string index
	inc	hl
	cp	(hl)		; compare with string length
	jp	nc,XEND		; end if string exhausted

	push	hl
	inc	hl
	ld	e,a
	ld	d,0
	add	hl,de		; index into string
	ld	a,(hl)		; get string char
	ld	(ARGS),a	; save it
	pop	hl
	ld	e,(hl)
	ld	d,0
	inc	hl
	add	hl,de		; skip string, point to begin of body text
	add	hl,bc		; index into macro text
	ld	a,(hl)		; get char
	cp	EOF		; end of text?
	jp	z,XC4		; branch if yes, start next iteration

	ld	de,REC
XC1:	ld	a,(hl)		; get char from macro text
	inc	hl
	inc	bc		; advance index
	or	a		; test for coded dummy parameter
	jp	p,XC3		; branch if not parameter
	ld	a,(ARGS)	; else use string char
XC3:	ld	(de),a		; save char in REC buf (no need for ovfl check)
	or	a		; end of line?
	jr	z,XC2		; branch if yes
	inc	de
	jr	XC1		; else loop for more
XC2:	pop	hl
	ld	(hl),c		; update text index
	inc	hl
	ld	(hl),b
	ret

XC4:	pop	hl		; next iteration
	push	hl
	xor	a
	ld	(hl),a		; reset text index
	inc	hl
	ld	(hl),a
	inc	hl
	inc	(hl)		; advance string index
	pop	hl
	jr	XIRPC		; restart execution
;
;	End of MACRO/REPT/IRP/IRPC execution
;
XEND:	pop	hl
	dec	hl
	dec	hl
	dec	hl
	dec	hl
	dec	hl
	call	MFREE		; release storage
	ld	hl,MACLVL
	dec	(hl)		; decrease macro execution level
	call	z,GBCOL		; if zero, perform garbage collection
	jp	GNR		; switch input back to GNR

;	SUBTTL	'EXITM pseudo-operator'
;
;	EXITM
;
ENDMAC:	ld	c,STMEXP
	call	FNDREC		; find top-level executing macro
	jp	c,OERROR	; error if not found: EXITM without MACRO
	push	hl
	inc	hl
	inc	hl
	inc	hl
	inc	hl
	ld	a,(hl)		; get saved conditional level
	ld	(CLEVEL),a
	ld	hl,CNDSTK
	ld	e,a
	ld	d,0
	sbc	hl,de		; note CY is still clear
	ld	(CONDSP),hl	; restore conditional stack pointer
	pop	hl
	call	MFREE		; release storage
	ld	hl,MACLVL
	dec	(hl)		; decrement macro execution level
	call	z,GBCOL
	ret

;	SUBTTL	'REPT pseudo-operator'
;
;	REPT structure as saved in high memory:
;
;	db	STMEXP		; type = MACRO expansion
;	dw	len		; length of following block:
;	db	$REPT		;  macro type
;	db	clevel		;  saved conditional level
;	dw	index		;  text index
;	dw	count		;  REPT argument
;	db	'body line 1',0	;  macro
;	db	'body line 2',0	;   body
;	db	...		;
;	db	EOF		;  end of macro
;
DFREPT:	ld	bc,2
	call	MCHECK
	jp	c,WERROR
	call	EVALNEW		; get argument
	ld	a,(EVMODE)
	or	a
	jp	z,DFR1
	call	RELERR		; can't be reloc
	ld	de,0		; null counter to prevent execution
DFR1:	ex	de,hl
	ld	hl,(SYMPTR)
	ld	(PARAMS),hl
	ld	(hl),0FFh	; no parameters
	inc	hl
	ld	(MACBGN),hl
	ld	(hl),e		; store counter value
	inc	hl
	ld	(hl),d
	inc	hl
	ld	(MACPTR),hl	; init macro def pointer

	ld	a,$REPT
	ld	(MACTYP),a
	jp	INCDFL		; increase macro def level

;	SUBTTL	'IRP pseudo-operator'

;	IRP structure as saved in high memory:
;
;	db	STMEXP		; type = MACRO expansion
;	dw	len		; length of the following block:
;	db	$IRP		;  macro type
;	db	clevel		;  saved conditional level
;	dw	index		;  text index
;	db	argidx		;  argument index
;	db	len,'arg1'	;  IRP argument 1
;	db	len,'arg2'	;  IRP argument 2
;	db	...		;
;	db	0FFh		;  end of argument list
;	db	'body line 1',0	;  macro
;	db	'body line 2',0	;   body
;	db	...		;
;	db	EOF		;  end of macro
;
DFIRP:	ld	bc,RECMAX	; hopefully enough - if there are a lot
	call	MCHECK		;  of '%vars' then argument list can
	jp	c,WERROR	;   quickly grow in size!!!
	ld	hl,(SYMPTR)
	ld	(MACPTR),hl
	ld	(PARAMS),hl
	call	ID
	ld	a,(IDLEN)
	or	a		; valid identifier?
	jr	nz,DP1		; yes -> branch
	call	OERROR		; no -> argument error
	ld	de,(MACPTR)
	jr	DP2
DP1:	ld	c,a
	ld	b,0
	ld	hl,IDBUF
	ld	de,(MACPTR)
	ld	(de),a		; store length
	inc	de
	ldir
DP2:	ld	a,0FFh
	ld	(de),a		; 0FFh marks end of params
	inc	de
	ld	(MACBGN),de	; set start address of body
	inc	a
	ld	(de),a		; arg index
	inc	de
	ld	(MACPTR),de
	call	GNC
	cp	','
	jp	nz,OERROR	; comma must follow
	call	GNC
	cp	'<'		; then '<'
	jp	nz,OERROR
DP3:	ld	de,(MACPTR)
	push	de
	inc	de		; length placeholder
	call	GETSTR
	ex	de,hl
	ld	(MACPTR),hl
	pop	de
	push	af
	or	a
	sbc	hl,de
	dec	hl
	ld	a,l
	ld	(de),a		; store length
	pop	af
	jr	c,DP4		; argument error, stop scanning?
	call	GNC
	or	a
	jr	z,DP4		; argument error (missing '>') and exit loop
	cp	'>'
	jr	z,DP5		; success, exit loop
	cp	','
	jr	z,DP3
	call	BACKUP
	jr	DP3
DP4:	call	OERROR
DP5:	ld	hl,(MACPTR)
	ld	(hl),0FFh	; end of argument list
	inc	hl
	ld	(MACPTR),hl
	ld	a,$IRP
	ld	(MACTYP),a
	jp	INCDFL		; increase macro def level
;
;	Skip blanks and get a single argument string until a comma or
;	another blank char is found. Angle brackets and/or quotes can
;	be used to delimit a substring containing spaces or commas.
;
GETSTR:	ld	c,0		; bracket nesting count
	call	GNC
	or	a
	ret	z
	ld	hl,(PTR1)
	dec	hl
GS0:	ld	a,(hl)		; since GNC converts char to uppercase
	inc	hl
	or	a
	jr	z,GS9
	cp	' '
	jr	z,GS6		; delimiters are spaces,
	cp	TAB
	jr	z,GS6		;  tabs
	cp	','
	jr	z,GS6		;   commas
	cp	';'
	jr	z,GS6		;    and semicolons
	cp	'<'
	jr	z,GS1		; opening bracket starts a substring
	cp	'>'
	jr	z,GS2
	cp	'%'		; percent sign followed by a var name or expr
	jr	z,GS5		;  expands to a numeric value
	cp	'!'
	jr	nz,GS7		; exclamation mark means escape char
	ld	a,(hl)
	inc	hl
	or	a
	scf
	jr	z,GS8
GS7:	ld	(de),a		; store char
	inc	de
	cp	27H		;'
	jr	z,GS3
	cp	'""'
	jr	nz,GS0
GS3:	ld	b,a		; get quote char into B
GS4:	ld	a,(hl)
	inc	hl
	or	a
	scf
	jr	z,GS8		; missing closing quote
	ld	(de),a
	inc	de
	cp	b
	jr	nz,GS4		; loop until closing quote found
	jr	GS0

GS1:	inc	c
	dec	c		; first opening bracket?
	jr	nz,GS11	
	inc	c		; yes: increment nesting level
	jr	GS0		;  and remove the bracket
GS11:	inc	c		; no: increment nesting level
	jr	GS7		;  but keep the bracket

GS2:	inc	c		; check bracket nesting
	dec	c		;  error if zero
;;	scf			;; do not tag as error here (caller will)
	jr	z,GS8		; '>' without '<'
	dec	c		; decrement nesting level
	jr	nz,GS7		;  keep the bracket if not zero
	inc	hl		;   else remove the bracket
	or	a		;    and finish
	jr	GS8

GS6:	inc	c
	dec	c		; store delimiters
	jr	nz,GS7		;  if inside substring
GS8:	dec	hl
	ld	(PTR1),hl
	ld	a,0
	ld	(de),a
	ret

GS9:	inc	c		; end of arg string,
	dec	c		;  check for balanced brackets
	jr	z,GS8
	scf			; missing '>'
	jr	GS8

GS5:	; expand %expr

	push	bc
	push	de
	ld	(PTR1),hl
	call	EVALNEW		; evaluate expression
	ld	a,(EVMODE)	; get mode
	and	0C0h+EXTSYM
	jr	z,GS51
	call	RELERR		; value must be Absolute
	and	EXTSYM
	jr	z,GS51
	ld	hl,0		; value is 0 for External
GS51:	pop	de
	call	CVTNUM		; convert to string
	ld	hl,(PTR1)
	pop	bc
	jp	GS0
;
;	Convert value in HL to ASCII string using the current base.
;	Store the result at (DE).
;
CVTNUM:	push	de
	ld	de,(RADIX)
	ld	bc,NUMBUF
	ld	a,0FFh		; end marker
	ld	(bc),a
	inc	bc
CN1:	push	bc
	xor	a
	ld	b,16		; HL=HL/E, remainder in A
DLOOP:	add	hl,hl
	rla
	cp	e
	jr	c,DNEXT
	sub	e
	inc	l
DNEXT:	djnz	DLOOP
	pop	bc
	ld	(bc),a		; save remainder
	inc	bc
	ld	a,h
	or	l		; result 0?
	jr	nz,CN1		; loop if not
	pop	de
CN2:	dec	bc
	ld	a,(bc)		; check digit
	cp	0FFh		; 0FFh is flag for no more
	ret	z		; if so, return
	add	a,90h		; else convert to ASCII
	daa
	adc	a,40h
	daa
	ld	(de),a		; store digit
	inc	de
	jr	CN2		; go back for more

;	SUBTTL	'IRPC pseudo-operator'

;	IRPC structure as saved in high memory:
;
;	db	STMEXP		; type = MACRO expansion
;	dw	len		; length of the following block:
;	db	$IRPC		;  macro type
;	db	clevel		;  saved conditional level
;	dw	index		;  text index
;	db	stridx		;  string index
;	db	len,'string'	;  IRPC argument string
;	db	'body line 1',0	;  macro
;	db	'body line 2',0	;   body
;	db	EOF		;  end of macro
;
DFIRPC:	ld	bc,RECMAX
	call	MCHECK
	jp	c,WERROR
	ld	hl,(SYMPTR)
	ld	(MACPTR),hl	; save macro build pointer
	ld	(PARAMS),hl
	call	ID		; get dummy parameter
	ld	a,(IDLEN)
	or	a		; valid identifier?
	jr	nz,DC1		; yes -> branch
	call	OERROR		; no -> argument error
	ld	de,(MACPTR)
	jr	DC2
DC1:	ld	c,a
	ld	b,0
	ld	hl,IDBUF
	ld	de,(MACPTR)
	ld	(de),a		; store length
	inc	de
	ldir
DC2:	ld	a,0FFh
	ld	(de),a		; 0FFh marks end of params
	inc	de
	ld	(MACBGN),de	; set start address of body
	inc	a
	ld	(de),a		; string index
	inc	de
	ld	(MACPTR),de
	call	GNC
	cp	','
	jp	nz,OERROR	; comma must follow
	ld	de,(MACPTR)
	push	de		; remember address of length field
	inc	de
	call	GNC
	ld	hl,(PTR1)
	dec	hl		; reload the original first char
	ld	a,(hl)		;  as GNC converted it to uppercase
	inc	hl
	cp	'<'
	ld	bc,1		; B = length, C = bracket nesting level
	jr	z,DC5
	dec	c
DC3:	ld	(de),a
	inc	b
	inc	de
	ld	a,(hl)
	or	a
	jr	z,DC4
	cp	' '
	jr	z,DC4
	cp	TAB
	jr	z,DC4
	cp	','
	jr	z,DC4
	cp	';'
	jr	z,DC4
	inc	hl
	jr	DC3
DC4:	ld	(PTR1),hl
	ld	(MACPTR),de
	pop	hl		; pop address of length field
	ld	(hl),b		; save length of string
	ld	a,$IRPC
	ld	(MACTYP),a
	jp	INCDFL		; increase macro def level

DC5:	ld	a,(hl)
	or	a
	jr	z,DC8
	inc	hl
	cp	'>'
	jr	z,DC7
	cp	'<'
	jr	nz,DC6
	inc	c
DC6:	ld	(de),a
	inc	b
	inc	de
	jr	DC5
DC7:	dec	c
	jr	nz,DC6
	jr	DC4
DC8:	call	ERRQ		; missing closing '>'
	jr	DC4

	psect	data

MDFLVL:	defs	1	; nested MACRO definition counter
MACTYP:	defs	1	; type of macro being defined
MACLVL:	defs	1	; macro execution level
MACBGN:	defs	2	; begin of macro body
MACPTR:	defs	2	; macro build ptr
PARAMS:	defs	2	; pointer to dummy parameters during MACRO build
ARGS:	defs	2	; pointer to argument list during MACRO expansion
LCLFLG:	defs	1	; LOCAL variable flag
LCLNUM:	defs	2	; LOCAL label number for next MACRO expansion
LBASE:	defs	2	; LOCAL label base number for executing MACRO
LCOUNT:	defs	1	; number of LOCAL variables in a MACRO
RCOUNT:	defs	1	; REC char count during MACRO expansion
NUMBUF:	defs	17	; buffer for numeric conv. (max size = binary base)

;	end
",12465,True,2862.1032288329297,median
"////
    AUTOGENERATED FILE - this file was generated via ./tools/gen_template_docs.py.
    Changes to .adoc or HTML files may be overwritten! Please change the
    generator or the input template (./*.in)
////
[id='rhpam73-prod-ref']
= rhpam73-prod.yaml template

Application template for a managed HA production runtime environment, for Red Hat Process Automation Manager 7.3



== Parameters

Templates allow you to define parameters which take on a value. That value is then substituted wherever the parameter is referenced.
References can be defined in any text field in the objects list field. Refer to the
https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html-single/developer_guide/#dev-guide-templates[Openshift documentation] for more information.

|=======================================================================
|Variable name |Image Environment Variable |Description |Example value |Required

|`APPLICATION_NAME` | -- | The name for the application. | myapp | True
|`MAVEN_REPO_ID` | `MAVEN_REPO_ID` | The id to use for the maven repository, if set. Default is generated randomly. | my-repo-id | False
|`MAVEN_REPO_URL` | `MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | http://nexus.nexus-project.svc.cluster.local:8081/nexus/content/groups/public/ | True
|`MAVEN_REPO_USERNAME` | `MAVEN_REPO_USERNAME` | Username to access the Maven repository, if required. | -- | False
|`MAVEN_REPO_PASSWORD` | `MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | -- | False
|`BUSINESS_CENTRAL_MAVEN_SERVICE` | `RHPAMCENTR_MAVEN_REPO_SERVICE` | The service name for the optional Business Central, where it can be reached, to allow service lookups (for maven repo usage), if required | myapp-rhpamcentr | False
|`BUSINESS_CENTRAL_MAVEN_USERNAME` | `RHPAMCENTR_MAVEN_REPO_USERNAME` | Username to access the Maven service hosted by Business Central inside EAP. | mavenUser | False
|`BUSINESS_CENTRAL_MAVEN_PASSWORD` | `RHPAMCENTR_MAVEN_REPO_PASSWORD` | Password to access the Maven service hosted by Business Central inside EAP. | maven1! | False
|`KIE_ADMIN_USER` | `KIE_ADMIN_USER` | KIE administrator username | adminUser | False
|`KIE_ADMIN_PWD` | `KIE_ADMIN_PWD` | KIE administrator password | -- | False
|`KIE_SERVER_USER` | `KIE_SERVER_USER` | KIE server username (Sets the org.kie.server.user system property) | executionUser | False
|`KIE_SERVER_PWD` | `KIE_SERVER_PWD` | KIE server password (Sets the org.kie.server.pwd system property) | -- | False
|`IMAGE_STREAM_NAMESPACE` | -- | Namespace in which the ImageStreams for Red Hat Middleware images are installed. These ImageStreams are normally installed in the openshift namespace. You should only need to modify this if you installed the ImageStreams in a different namespace/project. | openshift | True
|`KIE_SERVER_IMAGE_STREAM_NAME` | -- | The name of the image stream to use for KIE server. Default is ""rhpam73-kieserver-openshift"". | rhpam73-kieserver-openshift | True
|`IMAGE_STREAM_TAG` | -- | A named pointer to an image in an image stream. Default is ""1.0"". | 1.0 | True
|`SMART_ROUTER_HOSTNAME_HTTP` | -- | Custom hostname for http service route.  Leave blank for default hostname, e.g. <application-name>-smartrouter-<project>.<default-domain-suffix>' | -- | False
|`SMART_ROUTER_HOSTNAME_HTTPS` | -- | Custom hostname for https service route.  Leave blank for default hostname, e.g. secure-<application-name>-smartrouter-<project>.<default-domain-suffix>' | -- | False
|`KIE_SERVER_ROUTER_ID` | `KIE_SERVER_ROUTER_ID` | Router ID used when connecting to the controller (router property org.kie.server.router.id) | kie-server-router | True
|`KIE_SERVER_ROUTER_PROTOCOL` | `KIE_SERVER_ROUTER_PROTOCOL` | KIE server router protocol (Used to build the org.kie.server.router.url.external property) | http | False
|`KIE_SERVER_ROUTER_URL_EXTERNAL` | `KIE_SERVER_ROUTER_URL_EXTERNAL` | Public URL where the router can be found. Format http://<host>:<port>  (router property org.kie.server.router.url.external) | -- | False
|`KIE_SERVER_ROUTER_NAME` | `KIE_SERVER_ROUTER_NAME` | Router name used when connecting to the controller (router property org.kie.server.router.name) | KIE Server Router | True
|`KIE_SERVER_CONTROLLER_USER` | `KIE_SERVER_CONTROLLER_USER` | KIE server controller username (Sets the org.kie.server.controller.user system property) | controllerUser | False
|`KIE_SERVER_CONTROLLER_PWD` | `KIE_SERVER_CONTROLLER_PWD` | KIE server controller password (Sets the org.kie.server.controller.pwd system property) | -- | False
|`KIE_SERVER_CONTROLLER_TOKEN` | `KIE_SERVER_CONTROLLER_TOKEN` | KIE server controller token for bearer authentication (Sets the org.kie.server.controller.token system property) | -- | False
|`KIE_SERVER_PERSISTENCE_DS` | `KIE_SERVER_PERSISTENCE_DS` | KIE server persistence datasource (Sets the org.kie.server.persistence.ds system property) | java:/jboss/datasources/rhpam | False
|`POSTGRESQL_IMAGE_STREAM_NAMESPACE` | -- | Namespace in which the ImageStream for the PostgreSQL image is installed. The ImageStream is already installed in the openshift namespace. You should only need to modify this if you installed the ImageStream in a different namespace/project. Default is ""openshift"". | openshift | False
|`POSTGRESQL_IMAGE_STREAM_TAG` | -- | The PostgreSQL image version, which is intended to correspond to the PostgreSQL version. Default is ""10"". | 10 | False
|`KIE_SERVER_POSTGRESQL_USER` | `RHPAM_USERNAME` | KIE server PostgreSQL database username | rhpam | False
|`KIE_SERVER_POSTGRESQL_PWD` | `RHPAM_PASSWORD` | KIE server PostgreSQL database password | -- | False
|`KIE_SERVER_POSTGRESQL_DB` | `RHPAM_DATABASE` | KIE server PostgreSQL database name | rhpam7 | False
|`POSTGRESQL_MAX_PREPARED_TRANSACTIONS` | `POSTGRESQL_MAX_PREPARED_TRANSACTIONS` | Allows the PostgreSQL to handle XA transactions. | 100 | True
|`DB_VOLUME_CAPACITY` | -- | Size of persistent storage for the database volume. | 1Gi | True
|`KIE_SERVER_POSTGRESQL_DIALECT` | `KIE_SERVER_PERSISTENCE_DIALECT` | KIE server PostgreSQL Hibernate dialect | org.hibernate.dialect.PostgreSQLDialect | True
|`KIE_SERVER_MODE` | `KIE_SERVER_MODE` | The KIE Server mode. Valid values are 'DEVELOPMENT' or 'PRODUCTION'. (Sets the org.kie.server.mode system property). | `PRODUCTION` | False
|`KIE_MBEANS` | `KIE_MBEANS` | KIE server mbeans enabled/disabled (Sets the kie.mbeans and kie.scanner.mbeans system properties) | enabled | False
|`DROOLS_SERVER_FILTER_CLASSES` | `DROOLS_SERVER_FILTER_CLASSES` | KIE server class filtering (Sets the org.drools.server.filter.classes system property) | true | False
|`BUSINESS_CENTRAL_HOSTNAME_HTTP` | `HOSTNAME_HTTP` | Custom hostname for http service route.  Leave blank for default hostname, e.g.: <application-name>-rhpamcentrmon-<project>.<default-domain-suffix> | -- | False
|`BUSINESS_CENTRAL_HOSTNAME_HTTPS` | `HOSTNAME_HTTPS` | Custom hostname for https service route.  Leave blank for default hostname, e.g.: secure-<application-name>-rhpamcentrmon-<project>.<default-domain-suffix> | -- | False
|KIE_SERVER1_HOSTNAME_HTTP | `HOSTNAME_HTTP` | Custom hostname for http service route. Leave blank for default hostname, e.g.: <application-name>-kieserver-<project>.<default-domain-suffix> | -- | False
|KIE_SERVER1_HOSTNAME_HTTPS | `HOSTNAME_HTTPS` | Custom hostname for https service route.  Leave blank for default hostname, e.g.: secure-<application-name>-kieserver-<project>.<default-domain-suffix> | -- | False
|KIE_SERVER1_USE_SECURE_ROUTE_NAME | `KIE_SERVER_USE_SECURE_ROUTE_NAME` | If true, will use secure-APPLICATION_NAME-kieserver-1 vs. APPLICATION_NAME-kieserver-1 as the route name. | false | False
|KIE_SERVER2_HOSTNAME_HTTP | `HOSTNAME_HTTP` | Custom hostname for http service route. Leave blank for default hostname, e.g.: <application-name>-kieserver-<project>.<default-domain-suffix> | -- | False
|KIE_SERVER2_HOSTNAME_HTTPS | `HOSTNAME_HTTPS` | Custom hostname for https service route.  Leave blank for default hostname, e.g.: secure-<application-name>-kieserver-<project>.<default-domain-suffix> | -- | False
|KIE_SERVER2_USE_SECURE_ROUTE_NAME | `KIE_SERVER_USE_SECURE_ROUTE_NAME` | If true, will use secure-APPLICATION_NAME-kieserver-2 vs. APPLICATION_NAME-kieserver-2 as the route name. | false | False
|`BUSINESS_CENTRAL_HTTPS_SECRET` | -- | The name of the secret containing the keystore file | businesscentral-app-secret | True
|`BUSINESS_CENTRAL_HTTPS_KEYSTORE` | `HTTPS_KEYSTORE` | The name of the keystore file within the secret | keystore.jks | False
|`BUSINESS_CENTRAL_HTTPS_NAME` | `HTTPS_NAME` | The name associated with the server certificate | jboss | False
|`BUSINESS_CENTRAL_HTTPS_PASSWORD` | `HTTPS_PASSWORD` | The password for the keystore and certificate | mykeystorepass | False
|`KIE_SERVER_ROUTER_HTTPS_SECRET` | -- | The name of the secret containing the keystore file | smartrouter-app-secret | True
|`KIE_SERVER_ROUTER_HTTPS_KEYSTORE` | -- | The name of the keystore file within the secret | keystore.jks | False
|`KIE_SERVER_ROUTER_HTTPS_NAME` | `KIE_SERVER_ROUTER_TLS_KEYSTORE_KEYALIAS` | The name associated with the server certificate | jboss | False
|`KIE_SERVER_ROUTER_HTTPS_PASSWORD` | `KIE_SERVER_ROUTER_TLS_KEYSTORE_PASSWORD` | The password for the keystore and certificate | mykeystorepass | False
|`KIE_SERVER_HTTPS_SECRET` | -- | The name of the secret containing the keystore file | kieserver-app-secret | True
|`KIE_SERVER_HTTPS_KEYSTORE` | `HTTPS_KEYSTORE` | The name of the keystore file within the secret | keystore.jks | False
|`KIE_SERVER_HTTPS_NAME` | `HTTPS_NAME` | The name associated with the server certificate | jboss | False
|`KIE_SERVER_HTTPS_PASSWORD` | `HTTPS_PASSWORD` | The password for the keystore and certificate | mykeystorepass | False
|`KIE_SERVER_BYPASS_AUTH_USER` | `KIE_SERVER_BYPASS_AUTH_USER` | KIE server bypass auth user (Sets the org.kie.server.bypass.auth.user system property) | false | False
|`TIMER_SERVICE_DATA_STORE_REFRESH_INTERVAL` | `TIMER_SERVICE_DATA_STORE_REFRESH_INTERVAL` | Sets refresh-interval for the EJB timer service database-data-store. | 30000 | False
|`BUSINESS_CENTRAL_MEMORY_LIMIT` | -- | Business Central Monitoring Container memory limit | 2Gi | False
|`KIE_SERVER_MEMORY_LIMIT` | -- | KIE server Container memory limit | 1Gi | False
|`SMART_ROUTER_MEMORY_LIMIT` | -- | Smart Router Container memory limit | 512Mi | False
|`BUSINESS_CENTRAL_MONITORING_CONTAINER_REPLICAS` | -- | Business Central Monitoring Container Replicas, will define how much Business Central Monitoring containers will be started. | 3 | True
|`SMART_ROUTER_CONTAINER_REPLICAS` | -- | Smart Router Container Replicas, will define how much smart router containers will be started. | 2 | True
|`KIE_SERVER_CONTAINER_REPLICAS` | -- | KIE Server Container Replicas, will define how much KIE Server containers will be started. | 3 | True
|`SSO_URL` | `SSO_URL` | RH-SSO URL | https://rh-sso.example.com/auth | False
|`SSO_REALM` | `SSO_REALM` | RH-SSO Realm name | -- | False
|`BUSINESS_CENTRAL_SSO_CLIENT` | `SSO_CLIENT` | Business Central Monitoring RH-SSO Client name | -- | False
|`BUSINESS_CENTRAL_SSO_SECRET` | `SSO_SECRET` | Business Central Monitoring RH-SSO Client Secret | 252793ed-7118-4ca8-8dab-5622fa97d892 | False
|KIE_SERVER1_SSO_CLIENT | `SSO_CLIENT` | KIE Server 1 RH-SSO Client name | -- | False
|KIE_SERVER1_SSO_SECRET | `SSO_SECRET` | KIE Server 1 RH-SSO Client Secret | 252793ed-7118-4ca8-8dab-5622fa97d892 | False
|KIE_SERVER2_SSO_CLIENT | `SSO_CLIENT` | KIE Server 2 RH-SSO Client name | -- | False
|KIE_SERVER2_SSO_SECRET | `SSO_SECRET` | KIE Server 2 RH-SSO Client Secret | 252793ed-7118-4ca8-8dab-5622fa97d892 | False
|`SSO_USERNAME` | `SSO_USERNAME` | RH-SSO Realm Admin Username used to create the Client if it doesn't exist | -- | False
|`SSO_PASSWORD` | `SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client | -- | False
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | `SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation | false | False
|`SSO_PRINCIPAL_ATTRIBUTE` | `SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as username. | preferred_username | False
|`AUTH_LDAP_URL` | `AUTH_LDAP_URL` | LDAP Endpoint to connect for authentication | ldap://myldap.example.com | False
|`AUTH_LDAP_BIND_DN` | `AUTH_LDAP_BIND_DN` | Bind DN used for authentication | uid=admin,ou=users,ou=exmample,ou=com | False
|`AUTH_LDAP_BIND_CREDENTIAL` | `AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication | Password | False
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | `AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | -- | False
|`AUTH_LDAP_BASE_CTX_DN` | `AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | ou=users,ou=example,ou=com | False
|`AUTH_LDAP_BASE_FILTER` | `AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | (uid={0}) | False
|`AUTH_LDAP_SEARCH_SCOPE` | `AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `SUBTREE_SCOPE` | False
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | `AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | 10000 | False
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | `AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | distinguishedName | False
|`AUTH_LDAP_PARSE_USERNAME` | `AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the username. If set to true, the DN is parsed for the username. If set to false the DN is not parsed for the username. This option is used together with usernameBeginString and usernameEndString. | true | False
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | `AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | -- | False
|`AUTH_LDAP_USERNAME_END_STRING` | `AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | -- | False
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | `AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | memberOf | False
|`AUTH_LDAP_ROLES_CTX_DN` | `AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | ou=groups,ou=example,ou=com | False
|`AUTH_LDAP_ROLE_FILTER` | `AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | (memberOf={1}) | False
|`AUTH_LDAP_ROLE_RECURSION` | `AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | 1 | False
|`AUTH_LDAP_DEFAULT_ROLE` | `AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | guest | False
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | `AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | name | False
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | `AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | false | False
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | `AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | false | False
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | `AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | -- | False
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | `AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This property defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | -- | False
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | `AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | -- | False
|=======================================================================



== Objects

The CLI supports various object types. A list of these object types as well as their abbreviations
can be found in the https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/cli_reference/cli-reference-basic-cli-operations#object-types[Openshift documentation].


=== Services

A service is an abstraction which defines a logical set of pods and a policy by which to access them. Refer to the
https://cloud.google.com/container-engine/docs/services/[container-engine documentation] for more information.

|=============
|Service        |Port  |Name | Description

.2+| `${APPLICATION_NAME}-rhpamcentrmon`
|8080 | http
.2+| All the Business Central Monitoring web server's ports.
|8443 | https
.1+| `${APPLICATION_NAME}-rhpamcentrmon-ping`
|8888 | ping
.1+| The JGroups ping port for clustering.
.2+| `${APPLICATION_NAME}-smartrouter`
|9000 | http
.2+| The smart router server http and https ports.
|9443 | https
.2+| `${APPLICATION_NAME}-kieserver-1`
|8080 | http
.2+| All the KIE server web server's ports. (First KIE server)
|8443 | https
.1+| `${APPLICATION_NAME}-kieserver-1-ping`
|8888 | ping
.1+| The JGroups ping port for clustering.
.2+| `${APPLICATION_NAME}-kieserver-2`
|8080 | http
.2+| All the KIE server web server's ports. (Second KIE server)
|8443 | https
.1+| `${APPLICATION_NAME}-kieserver-2-ping`
|8888 | ping
.1+| The JGroups ping port for clustering.
.1+| `${APPLICATION_NAME}-postgresql-1`
|5432 | --
.1+| The first database server's port.
.1+| `${APPLICATION_NAME}-postgresql-2`
|5432 | --
.1+| The second database server's port.
|=============



=== Routes

A route is a way to expose a service by giving it an externally-reachable hostname such as `www.example.com`. A defined route and the endpoints
identified by its service can be consumed by a router to provide named connectivity from external clients to your applications. Each route consists
of a route name, service selector, and (optionally) security configuration. Refer to the
https://access.redhat.com/documentation/en-us/openshift_enterprise/3.2/html/architecture/core-concepts#architecture-core-concepts-routes[Openshift documentation] for more information.

|=============
| Service    | Security | Hostname

|`${APPLICATION_NAME}-rhpamcentrmon-http` | none | `${BUSINESS_CENTRAL_HOSTNAME_HTTP}`
|`${APPLICATION_NAME}-rhpamcentrmon-https` | TLS passthrough | `${BUSINESS_CENTRAL_HOSTNAME_HTTPS}`
|`${APPLICATION_NAME}-kieserver-1-http` | none | `${KIE_SERVER1_HOSTNAME_HTTP}`
|`${APPLICATION_NAME}-kieserver-1-https` | TLS passthrough | `${KIE_SERVER1_HOSTNAME_HTTPS}`
|`${APPLICATION_NAME}-kieserver-2-http` | none | `${KIE_SERVER2_HOSTNAME_HTTP}`
|`${APPLICATION_NAME}-kieserver-2-https` | TLS passthrough | `${KIE_SERVER2_HOSTNAME_HTTPS}`
|`${APPLICATION_NAME}-smartrouter-http` | none | `${SMART_ROUTER_HOSTNAME_HTTP}`
|`${APPLICATION_NAME}-smartrouter-https` | TLS passthrough | `${SMART_ROUTER_HOSTNAME_HTTPS}`
|=============




=== Deployment Configurations

A deployment in OpenShift is a replication controller based on a user defined template called a deployment configuration. Deployments are created manually or in response to triggered events.
Refer to the https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/deployments#dev-guide-how-deployments-work[Openshift documentation] for more information.


==== Triggers

A trigger drives the creation of new deployments in response to events, both inside and outside OpenShift. Refer to the
https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/deployments#triggers[Openshift documentation] for more information.

|============
|Deployment | Triggers

|`${APPLICATION_NAME}-rhpamcentrmon` | ImageChange
|`${APPLICATION_NAME}-smartrouter` | ImageChange
|`${APPLICATION_NAME}-kieserver-1` | ImageChange
|`${APPLICATION_NAME}-postgresql-1` | ImageChange
|`${APPLICATION_NAME}-kieserver-2` | ImageChange
|`${APPLICATION_NAME}-postgresql-2` | ImageChange
|============



==== Replicas

A replication controller ensures that a specified number of pod ""replicas"" are running at any one time.
If there are too many, the replication controller kills some pods. If there are too few, it starts more.
Refer to the https://cloud.google.com/container-engine/docs/replicationcontrollers/[container-engine documentation]
for more information.

|============
|Deployment | Replicas

|`${APPLICATION_NAME}-rhpamcentrmon` | 3
|`${APPLICATION_NAME}-smartrouter` | 2
|`${APPLICATION_NAME}-kieserver-1` | 3
|`${APPLICATION_NAME}-postgresql-1` | 1
|`${APPLICATION_NAME}-kieserver-2` | 3
|`${APPLICATION_NAME}-postgresql-2` | 1
|============


==== Pod Template


===== Service Accounts

Service accounts are API objects that exist within each project. They can be created or deleted like any other API object. Refer to the
https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/dev-guide-service-accounts#dev-managing-service-accounts[Openshift documentation] for more
information.

|============
|Deployment | Service Account

|`${APPLICATION_NAME}-kieserver-1` | `${APPLICATION_NAME}-kieserver`
|`${APPLICATION_NAME}-kieserver-2` | `${APPLICATION_NAME}-kieserver`
|============



===== Image

|============
|Deployment | Image

|`${APPLICATION_NAME}-rhpamcentrmon` | rhpam73-businesscentral-monitoring-openshift
|`${APPLICATION_NAME}-smartrouter` | rhpam73-smartrouter-openshift
|`${APPLICATION_NAME}-kieserver-1` | `${KIE_SERVER_IMAGE_STREAM_NAME}`
|`${APPLICATION_NAME}-postgresql-1` | postgresql
|`${APPLICATION_NAME}-kieserver-2` | `${KIE_SERVER_IMAGE_STREAM_NAME}`
|`${APPLICATION_NAME}-postgresql-2` | postgresql
|============



===== Readiness Probe


.${APPLICATION_NAME}-rhpamcentrmon
----
/bin/bash -c curl --fail --silent -u '${KIE_ADMIN_USER}:${KIE_ADMIN_PWD}' http://localhost:8080/kie-wb.jsp
----

.${APPLICATION_NAME}-kieserver-1
----
/bin/bash -c curl --fail --silent -u '${KIE_ADMIN_USER}:${KIE_ADMIN_PWD}' http://localhost:8080/services/rest/server/readycheck
----

.${APPLICATION_NAME}-postgresql-1
----
/usr/libexec/check-container
----

.${APPLICATION_NAME}-kieserver-2
----
/bin/bash -c curl --fail --silent -u '${KIE_ADMIN_USER}:${KIE_ADMIN_PWD}' http://localhost:8080/services/rest/server/readycheck
----

.${APPLICATION_NAME}-postgresql-2
----
/usr/libexec/check-container
----




===== Liveness Probe


.${APPLICATION_NAME}-rhpamcentrmon
----
/bin/bash -c curl --fail --silent -u '${KIE_ADMIN_USER}:${KIE_ADMIN_PWD}' http://localhost:8080/kie-wb.jsp
----

.${APPLICATION_NAME}-kieserver-1
----
/bin/bash -c curl --fail --silent -u '${KIE_ADMIN_USER}:${KIE_ADMIN_PWD}' http://localhost:8080/services/rest/server/readycheck
----

.${APPLICATION_NAME}-postgresql-1
----
/usr/libexec/check-container
----

.${APPLICATION_NAME}-kieserver-2
----
/bin/bash -c curl --fail --silent -u '${KIE_ADMIN_USER}:${KIE_ADMIN_PWD}' http://localhost:8080/services/rest/server/readycheck
----

.${APPLICATION_NAME}-postgresql-2
----
/usr/libexec/check-container
----




===== Exposed Ports

|=============
|Deployments | Name  | Port  | Protocol

.4+| `${APPLICATION_NAME}-rhpamcentrmon`
|jolokia | 8778 | `TCP`
|http | 8080 | `TCP`
|https | 8443 | `TCP`
|ping | 8888 | `TCP`
.1+| `${APPLICATION_NAME}-smartrouter`
|http | 9000 | `TCP`
.4+| `${APPLICATION_NAME}-kieserver-1`
|jolokia | 8778 | `TCP`
|http | 8080 | `TCP`
|https | 8443 | `TCP`
|ping | 8888 | `TCP`
.1+| `${APPLICATION_NAME}-postgresql-1`
|-- | 5432 | `TCP`
.4+| `${APPLICATION_NAME}-kieserver-2`
|jolokia | 8778 | `TCP`
|http | 8080 | `TCP`
|https | 8443 | `TCP`
|ping | 8888 | `TCP`
.1+| `${APPLICATION_NAME}-postgresql-2`
|-- | 5432 | `TCP`
|=============



===== Image Environment Variables

|=======================================================================
|Deployment |Variable name |Description |Example value

.52+| `${APPLICATION_NAME}-rhpamcentrmon`
|`KIE_ADMIN_PWD` | KIE administrator password | `${KIE_ADMIN_PWD}`
|`KIE_ADMIN_USER` | KIE administrator username | `${KIE_ADMIN_USER}`
|`KIE_SERVER_PWD` | KIE server password (Sets the org.kie.server.pwd system property) | `${KIE_SERVER_PWD}`
|`KIE_SERVER_USER` | KIE server username (Sets the org.kie.server.user system property) | `${KIE_SERVER_USER}`
|`MAVEN_REPO_ID` | The id to use for the maven repository, if set. Default is generated randomly. | `${MAVEN_REPO_ID}`
|`MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | `${MAVEN_REPO_URL}`
|`MAVEN_REPO_USERNAME` | Username to access the Maven repository, if required. | `${MAVEN_REPO_USERNAME}`
|`MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | `${MAVEN_REPO_PASSWORD}`
|`KIE_SERVER_CONTROLLER_USER` | KIE server controller username (Sets the org.kie.server.controller.user system property) | `${KIE_SERVER_CONTROLLER_USER}`
|`KIE_SERVER_CONTROLLER_PWD` | KIE server controller password (Sets the org.kie.server.controller.pwd system property) | `${KIE_SERVER_CONTROLLER_PWD}`
|`KIE_SERVER_CONTROLLER_TOKEN` | KIE server controller token for bearer authentication (Sets the org.kie.server.controller.token system property) | `${KIE_SERVER_CONTROLLER_TOKEN}`
|`HTTPS_KEYSTORE_DIR` | -- | `/etc/businesscentral-secret-volume`
|`HTTPS_KEYSTORE` | The name of the keystore file within the secret | `${BUSINESS_CENTRAL_HTTPS_KEYSTORE}`
|`HTTPS_NAME` | The name associated with the server certificate | `${BUSINESS_CENTRAL_HTTPS_NAME}`
|`HTTPS_PASSWORD` | The password for the keystore and certificate | `${BUSINESS_CENTRAL_HTTPS_PASSWORD}`
|`JGROUPS_PING_PROTOCOL` | -- | openshift.DNS_PING
|`OPENSHIFT_DNS_PING_SERVICE_NAME` | -- | `${APPLICATION_NAME}-rhpamcentrmon-ping`
|`OPENSHIFT_DNS_PING_SERVICE_PORT` | -- | 8888
|`SSO_URL` | RH-SSO URL | `${SSO_URL}`
|`SSO_OPENIDCONNECT_DEPLOYMENTS` | -- | ROOT.war
|`SSO_REALM` | RH-SSO Realm name | `${SSO_REALM}`
|`SSO_SECRET` | Business Central Monitoring RH-SSO Client Secret | `${BUSINESS_CENTRAL_SSO_SECRET}`
|`SSO_CLIENT` | Business Central Monitoring RH-SSO Client name | `${BUSINESS_CENTRAL_SSO_CLIENT}`
|`SSO_USERNAME` | RH-SSO Realm Admin Username used to create the Client if it doesn't exist | `${SSO_USERNAME}`
|`SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client | `${SSO_PASSWORD}`
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation | `${SSO_DISABLE_SSL_CERTIFICATE_VALIDATION}`
|`SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as username. | `${SSO_PRINCIPAL_ATTRIBUTE}`
|`HOSTNAME_HTTP` | Custom hostname for http service route.  Leave blank for default hostname, e.g.: <application-name>-rhpamcentrmon-<project>.<default-domain-suffix> | `${BUSINESS_CENTRAL_HOSTNAME_HTTP}`
|`HOSTNAME_HTTPS` | Custom hostname for https service route.  Leave blank for default hostname, e.g.: secure-<application-name>-rhpamcentrmon-<project>.<default-domain-suffix> | `${BUSINESS_CENTRAL_HOSTNAME_HTTPS}`
|`AUTH_LDAP_URL` | LDAP Endpoint to connect for authentication | `${AUTH_LDAP_URL}`
|`AUTH_LDAP_BIND_DN` | Bind DN used for authentication | `${AUTH_LDAP_BIND_DN}`
|`AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication | `${AUTH_LDAP_BIND_CREDENTIAL}`
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | `${AUTH_LDAP_JAAS_SECURITY_DOMAIN}`
|`AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | `${AUTH_LDAP_BASE_CTX_DN}`
|`AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | `${AUTH_LDAP_BASE_FILTER}`
|`AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `${AUTH_LDAP_SEARCH_SCOPE}`
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | `${AUTH_LDAP_SEARCH_TIME_LIMIT}`
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | `${AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE}`
|`AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the username. If set to true, the DN is parsed for the username. If set to false the DN is not parsed for the username. This option is used together with usernameBeginString and usernameEndString. | `${AUTH_LDAP_PARSE_USERNAME}`
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_BEGIN_STRING}`
|`AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_END_STRING}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | `${AUTH_LDAP_ROLE_ATTRIBUTE_ID}`
|`AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | `${AUTH_LDAP_ROLES_CTX_DN}`
|`AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | `${AUTH_LDAP_ROLE_FILTER}`
|`AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | `${AUTH_LDAP_ROLE_RECURSION}`
|`AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | `${AUTH_LDAP_DEFAULT_ROLE}`
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | `${AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID}`
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | `${AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | `${AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN}`
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | `${AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK}`
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This property defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | `${AUTH_ROLE_MAPPER_ROLES_PROPERTIES}`
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | `${AUTH_ROLE_MAPPER_REPLACE_ROLE}`
.17+| `${APPLICATION_NAME}-smartrouter`
|`KIE_SERVER_ROUTER_HOST` | -- | --
|`KIE_SERVER_ROUTER_PORT` | -- | 9000
|`KIE_SERVER_ROUTER_PORT_TLS` | -- | 9443
|`KIE_SERVER_ROUTER_URL_EXTERNAL` | Public URL where the router can be found. Format http://<host>:<port>  (router property org.kie.server.router.url.external) | `${KIE_SERVER_ROUTER_URL_EXTERNAL}`
|`KIE_SERVER_ROUTER_ID` | Router ID used when connecting to the controller (router property org.kie.server.router.id) | `${KIE_SERVER_ROUTER_ID}`
|`KIE_SERVER_ROUTER_NAME` | Router name used when connecting to the controller (router property org.kie.server.router.name) | `${KIE_SERVER_ROUTER_NAME}`
|`KIE_SERVER_ROUTER_PROTOCOL` | KIE server router protocol (Used to build the org.kie.server.router.url.external property) | `${KIE_SERVER_ROUTER_PROTOCOL}`
|`KIE_SERVER_ROUTER_TLS_KEYSTORE_KEYALIAS` | The name associated with the server certificate | `${KIE_SERVER_ROUTER_HTTPS_NAME}`
|`KIE_SERVER_ROUTER_TLS_KEYSTORE_PASSWORD` | The password for the keystore and certificate | `${KIE_SERVER_ROUTER_HTTPS_PASSWORD}`
|`KIE_SERVER_ROUTER_TLS_KEYSTORE` | -- | `/etc/smartrouter-secret-volume/${KIE_SERVER_ROUTER_HTTPS_KEYSTORE}`
|`KIE_SERVER_CONTROLLER_USER` | KIE server controller username (Sets the org.kie.server.controller.user system property) | `${KIE_SERVER_CONTROLLER_USER}`
|`KIE_SERVER_CONTROLLER_PWD` | KIE server controller password (Sets the org.kie.server.controller.pwd system property) | `${KIE_SERVER_CONTROLLER_PWD}`
|`KIE_SERVER_CONTROLLER_TOKEN` | KIE server controller token for bearer authentication (Sets the org.kie.server.controller.token system property) | `${KIE_SERVER_CONTROLLER_TOKEN}`
|`KIE_SERVER_CONTROLLER_SERVICE` | -- | `${APPLICATION_NAME}-rhpamcentrmon`
|`KIE_SERVER_CONTROLLER_PROTOCOL` | -- | http
|`KIE_SERVER_ROUTER_REPO` | -- | `/opt/rhpam-smartrouter/data`
|`KIE_SERVER_ROUTER_CONFIG_WATCHER_ENABLED` | -- | true
.83+| `${APPLICATION_NAME}-kieserver-1`
|`KIE_ADMIN_USER` | KIE administrator username | `${KIE_ADMIN_USER}`
|`KIE_ADMIN_PWD` | KIE administrator password | `${KIE_ADMIN_PWD}`
|`KIE_SERVER_MODE` | The KIE Server mode. Valid values are 'DEVELOPMENT' or 'PRODUCTION'. (Sets the org.kie.server.mode system property). | `${KIE_SERVER_MODE}`
|`KIE_MBEANS` | KIE server mbeans enabled/disabled (Sets the kie.mbeans and kie.scanner.mbeans system properties) | `${KIE_MBEANS}`
|`DROOLS_SERVER_FILTER_CLASSES` | KIE server class filtering (Sets the org.drools.server.filter.classes system property) | `${DROOLS_SERVER_FILTER_CLASSES}`
|`KIE_SERVER_BYPASS_AUTH_USER` | KIE server bypass auth user (Sets the org.kie.server.bypass.auth.user system property) | `${KIE_SERVER_BYPASS_AUTH_USER}`
|`KIE_SERVER_CONTROLLER_USER` | KIE server controller username (Sets the org.kie.server.controller.user system property) | `${KIE_SERVER_CONTROLLER_USER}`
|`KIE_SERVER_CONTROLLER_PWD` | KIE server controller password (Sets the org.kie.server.controller.pwd system property) | `${KIE_SERVER_CONTROLLER_PWD}`
|`KIE_SERVER_CONTROLLER_TOKEN` | KIE server controller token for bearer authentication (Sets the org.kie.server.controller.token system property) | `${KIE_SERVER_CONTROLLER_TOKEN}`
|`KIE_SERVER_CONTROLLER_SERVICE` | -- | `${APPLICATION_NAME}-rhpamcentrmon`
|`KIE_SERVER_CONTROLLER_PROTOCOL` | -- | ws
|`KIE_SERVER_ID` | -- | `${APPLICATION_NAME}-kieserver-1`
|`KIE_SERVER_ROUTE_NAME` | -- | `${APPLICATION_NAME}-kieserver-1`
|`KIE_SERVER_USE_SECURE_ROUTE_NAME` | If true, will use secure-APPLICATION_NAME-kieserver-1 vs. APPLICATION_NAME-kieserver-1 as the route name. | `${KIE_SERVER1_USE_SECURE_ROUTE_NAME}`
|`KIE_SERVER_USER` | KIE server username (Sets the org.kie.server.user system property) | `${KIE_SERVER_USER}`
|`KIE_SERVER_PWD` | KIE server password (Sets the org.kie.server.pwd system property) | `${KIE_SERVER_PWD}`
|`KIE_SERVER_CONTAINER_DEPLOYMENT` | -- | 
|`MAVEN_REPOS` | -- | RHPAMCENTR,EXTERNAL
|`RHPAMCENTR_MAVEN_REPO_SERVICE` | The service name for the optional Business Central, where it can be reached, to allow service lookups (for maven repo usage), if required | `${BUSINESS_CENTRAL_MAVEN_SERVICE}`
|`RHPAMCENTR_MAVEN_REPO_PATH` | -- | `/maven2/`
|`RHPAMCENTR_MAVEN_REPO_USERNAME` | Username to access the Maven service hosted by Business Central inside EAP. | `${BUSINESS_CENTRAL_MAVEN_USERNAME}`
|`RHPAMCENTR_MAVEN_REPO_PASSWORD` | Password to access the Maven service hosted by Business Central inside EAP. | `${BUSINESS_CENTRAL_MAVEN_PASSWORD}`
|`EXTERNAL_MAVEN_REPO_ID` | The id to use for the maven repository, if set. Default is generated randomly. | `${MAVEN_REPO_ID}`
|`EXTERNAL_MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | `${MAVEN_REPO_URL}`
|`EXTERNAL_MAVEN_REPO_USERNAME` | Username to access the Maven repository, if required. | `${MAVEN_REPO_USERNAME}`
|`EXTERNAL_MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | `${MAVEN_REPO_PASSWORD}`
|`KIE_SERVER_ROUTER_SERVICE` | -- | `${APPLICATION_NAME}-smartrouter`
|`KIE_SERVER_ROUTER_PORT` | -- | 9000
|`KIE_SERVER_ROUTER_PROTOCOL` | KIE server router protocol (Used to build the org.kie.server.router.url.external property) | `${KIE_SERVER_ROUTER_PROTOCOL}`
|`KIE_SERVER_PERSISTENCE_DS` | KIE server persistence datasource (Sets the org.kie.server.persistence.ds system property) | `${KIE_SERVER_PERSISTENCE_DS}`
|`DATASOURCES` | -- | `RHPAM`
|`RHPAM_JNDI` | KIE server persistence datasource (Sets the org.kie.server.persistence.ds system property) | `${KIE_SERVER_PERSISTENCE_DS}`
|`RHPAM_JTA` | -- | true
|`RHPAM_DATABASE` | KIE server PostgreSQL database name | `${KIE_SERVER_POSTGRESQL_DB}`
|`RHPAM_DRIVER` | -- | postgresql
|`KIE_SERVER_PERSISTENCE_DIALECT` | KIE server PostgreSQL Hibernate dialect | `${KIE_SERVER_POSTGRESQL_DIALECT}`
|`RHPAM_USERNAME` | KIE server PostgreSQL database username | `${KIE_SERVER_POSTGRESQL_USER}`
|`RHPAM_PASSWORD` | KIE server PostgreSQL database password | `${KIE_SERVER_POSTGRESQL_PWD}`
|`RHPAM_SERVICE_HOST` | -- | `${APPLICATION_NAME}-postgresql-1`
|`RHPAM_SERVICE_PORT` | -- | 5432
|`TIMER_SERVICE_DATA_STORE` | -- | `${APPLICATION_NAME}-postgresql-1`
|`TIMER_SERVICE_DATA_STORE_REFRESH_INTERVAL` | Sets refresh-interval for the EJB timer service database-data-store. | `${TIMER_SERVICE_DATA_STORE_REFRESH_INTERVAL}`
|`HTTPS_KEYSTORE_DIR` | -- | `/etc/kieserver-secret-volume`
|`HTTPS_KEYSTORE` | The name of the keystore file within the secret | `${KIE_SERVER_HTTPS_KEYSTORE}`
|`HTTPS_NAME` | The name associated with the server certificate | `${KIE_SERVER_HTTPS_NAME}`
|`HTTPS_PASSWORD` | The password for the keystore and certificate | `${KIE_SERVER_HTTPS_PASSWORD}`
|`JGROUPS_PING_PROTOCOL` | -- | openshift.DNS_PING
|`OPENSHIFT_DNS_PING_SERVICE_NAME` | -- | `${APPLICATION_NAME}-kieserver-1-ping`
|`OPENSHIFT_DNS_PING_SERVICE_PORT` | -- | 8888
|`SSO_URL` | RH-SSO URL | `${SSO_URL}`
|`SSO_OPENIDCONNECT_DEPLOYMENTS` | -- | ROOT.war
|`SSO_REALM` | RH-SSO Realm name | `${SSO_REALM}`
|`SSO_SECRET` | KIE Server 1 RH-SSO Client Secret | `${KIE_SERVER1_SSO_SECRET}`
|`SSO_CLIENT` | KIE Server 1 RH-SSO Client name | `${KIE_SERVER1_SSO_CLIENT}`
|`SSO_USERNAME` | RH-SSO Realm Admin Username used to create the Client if it doesn't exist | `${SSO_USERNAME}`
|`SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client | `${SSO_PASSWORD}`
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation | `${SSO_DISABLE_SSL_CERTIFICATE_VALIDATION}`
|`SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as username. | `${SSO_PRINCIPAL_ATTRIBUTE}`
|`HOSTNAME_HTTP` | Custom hostname for http service route. Leave blank for default hostname, e.g.: <application-name>-kieserver-<project>.<default-domain-suffix> | `${KIE_SERVER1_HOSTNAME_HTTP}`
|`HOSTNAME_HTTPS` | Custom hostname for https service route.  Leave blank for default hostname, e.g.: secure-<application-name>-kieserver-<project>.<default-domain-suffix> | `${KIE_SERVER1_HOSTNAME_HTTPS}`
|`AUTH_LDAP_URL` | LDAP Endpoint to connect for authentication | `${AUTH_LDAP_URL}`
|`AUTH_LDAP_BIND_DN` | Bind DN used for authentication | `${AUTH_LDAP_BIND_DN}`
|`AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication | `${AUTH_LDAP_BIND_CREDENTIAL}`
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | `${AUTH_LDAP_JAAS_SECURITY_DOMAIN}`
|`AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | `${AUTH_LDAP_BASE_CTX_DN}`
|`AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | `${AUTH_LDAP_BASE_FILTER}`
|`AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `${AUTH_LDAP_SEARCH_SCOPE}`
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | `${AUTH_LDAP_SEARCH_TIME_LIMIT}`
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | `${AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE}`
|`AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the username. If set to true, the DN is parsed for the username. If set to false the DN is not parsed for the username. This option is used together with usernameBeginString and usernameEndString. | `${AUTH_LDAP_PARSE_USERNAME}`
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_BEGIN_STRING}`
|`AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_END_STRING}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | `${AUTH_LDAP_ROLE_ATTRIBUTE_ID}`
|`AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | `${AUTH_LDAP_ROLES_CTX_DN}`
|`AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | `${AUTH_LDAP_ROLE_FILTER}`
|`AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | `${AUTH_LDAP_ROLE_RECURSION}`
|`AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | `${AUTH_LDAP_DEFAULT_ROLE}`
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | `${AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID}`
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | `${AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | `${AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN}`
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | `${AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK}`
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This property defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | `${AUTH_ROLE_MAPPER_ROLES_PROPERTIES}`
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | `${AUTH_ROLE_MAPPER_REPLACE_ROLE}`
.4+| `${APPLICATION_NAME}-postgresql-1`
|`POSTGRESQL_USER` | KIE server PostgreSQL database username | `${KIE_SERVER_POSTGRESQL_USER}`
|`POSTGRESQL_PASSWORD` | KIE server PostgreSQL database password | `${KIE_SERVER_POSTGRESQL_PWD}`
|`POSTGRESQL_DATABASE` | KIE server PostgreSQL database name | `${KIE_SERVER_POSTGRESQL_DB}`
|`POSTGRESQL_MAX_PREPARED_TRANSACTIONS` | Allows the PostgreSQL to handle XA transactions. | `${POSTGRESQL_MAX_PREPARED_TRANSACTIONS}`
.81+| `${APPLICATION_NAME}-kieserver-2`
|`DROOLS_SERVER_FILTER_CLASSES` | KIE server class filtering (Sets the org.drools.server.filter.classes system property) | `${DROOLS_SERVER_FILTER_CLASSES}`
|`KIE_ADMIN_USER` | KIE administrator username | `${KIE_ADMIN_USER}`
|`KIE_ADMIN_PWD` | KIE administrator password | `${KIE_ADMIN_PWD}`
|`KIE_MBEANS` | KIE server mbeans enabled/disabled (Sets the kie.mbeans and kie.scanner.mbeans system properties) | `${KIE_MBEANS}`
|`KIE_SERVER_BYPASS_AUTH_USER` | KIE server bypass auth user (Sets the org.kie.server.bypass.auth.user system property) | `${KIE_SERVER_BYPASS_AUTH_USER}`
|`KIE_SERVER_CONTROLLER_USER` | KIE server controller username (Sets the org.kie.server.controller.user system property) | `${KIE_SERVER_CONTROLLER_USER}`
|`KIE_SERVER_CONTROLLER_PWD` | KIE server controller password (Sets the org.kie.server.controller.pwd system property) | `${KIE_SERVER_CONTROLLER_PWD}`
|`KIE_SERVER_CONTROLLER_TOKEN` | KIE server controller token for bearer authentication (Sets the org.kie.server.controller.token system property) | `${KIE_SERVER_CONTROLLER_TOKEN}`
|`KIE_SERVER_CONTROLLER_SERVICE` | -- | `${APPLICATION_NAME}-rhpamcentrmon`
|`KIE_SERVER_CONTROLLER_PROTOCOL` | -- | ws
|`KIE_SERVER_ID` | -- | `${APPLICATION_NAME}-kieserver-2`
|`KIE_SERVER_ROUTE_NAME` | -- | `${APPLICATION_NAME}-kieserver-2`
|`KIE_SERVER_USE_SECURE_ROUTE_NAME` | If true, will use secure-APPLICATION_NAME-kieserver-2 vs. APPLICATION_NAME-kieserver-2 as the route name. | `${KIE_SERVER2_USE_SECURE_ROUTE_NAME}`
|`KIE_SERVER_USER` | KIE server username (Sets the org.kie.server.user system property) | `${KIE_SERVER_USER}`
|`KIE_SERVER_PWD` | KIE server password (Sets the org.kie.server.pwd system property) | `${KIE_SERVER_PWD}`
|`KIE_SERVER_CONTAINER_DEPLOYMENT` | -- | 
|`MAVEN_REPOS` | -- | RHPAMCENTR,EXTERNAL
|`RHPAMCENTR_MAVEN_REPO_SERVICE` | The service name for the optional Business Central, where it can be reached, to allow service lookups (for maven repo usage), if required | `${BUSINESS_CENTRAL_MAVEN_SERVICE}`
|`RHPAMCENTR_MAVEN_REPO_PATH` | -- | `/maven2/`
|`RHPAMCENTR_MAVEN_REPO_USERNAME` | Username to access the Maven service hosted by Business Central inside EAP. | `${BUSINESS_CENTRAL_MAVEN_USERNAME}`
|`RHPAMCENTR_MAVEN_REPO_PASSWORD` | Password to access the Maven service hosted by Business Central inside EAP. | `${BUSINESS_CENTRAL_MAVEN_PASSWORD}`
|`EXTERNAL_MAVEN_REPO_ID` | The id to use for the maven repository, if set. Default is generated randomly. | `${MAVEN_REPO_ID}`
|`EXTERNAL_MAVEN_REPO_URL` | Fully qualified URL to a Maven repository or service. | `${MAVEN_REPO_URL}`
|`EXTERNAL_MAVEN_REPO_USERNAME` | Username to access the Maven repository, if required. | `${MAVEN_REPO_USERNAME}`
|`EXTERNAL_MAVEN_REPO_PASSWORD` | Password to access the Maven repository, if required. | `${MAVEN_REPO_PASSWORD}`
|`KIE_SERVER_ROUTER_SERVICE` | -- | `${APPLICATION_NAME}-smartrouter`
|`KIE_SERVER_ROUTER_PORT` | -- | 9000
|`KIE_SERVER_ROUTER_PROTOCOL` | KIE server router protocol (Used to build the org.kie.server.router.url.external property) | `${KIE_SERVER_ROUTER_PROTOCOL}`
|`KIE_SERVER_PERSISTENCE_DS` | KIE server persistence datasource (Sets the org.kie.server.persistence.ds system property) | `${KIE_SERVER_PERSISTENCE_DS}`
|`DATASOURCES` | -- | `RHPAM`
|`RHPAM_JNDI` | KIE server persistence datasource (Sets the org.kie.server.persistence.ds system property) | `${KIE_SERVER_PERSISTENCE_DS}`
|`RHPAM_JTA` | -- | true
|`RHPAM_DATABASE` | KIE server PostgreSQL database name | `${KIE_SERVER_POSTGRESQL_DB}`
|`RHPAM_DRIVER` | -- | postgresql
|`KIE_SERVER_PERSISTENCE_DIALECT` | KIE server PostgreSQL Hibernate dialect | `${KIE_SERVER_POSTGRESQL_DIALECT}`
|`RHPAM_USERNAME` | KIE server PostgreSQL database username | `${KIE_SERVER_POSTGRESQL_USER}`
|`RHPAM_PASSWORD` | KIE server PostgreSQL database password | `${KIE_SERVER_POSTGRESQL_PWD}`
|`RHPAM_SERVICE_HOST` | -- | `${APPLICATION_NAME}-postgresql-2`
|`RHPAM_SERVICE_PORT` | -- | 5432
|`TIMER_SERVICE_DATA_STORE_REFRESH_INTERVAL` | Sets refresh-interval for the EJB timer service database-data-store. | `${TIMER_SERVICE_DATA_STORE_REFRESH_INTERVAL}`
|`HTTPS_KEYSTORE_DIR` | -- | `/etc/kieserver-secret-volume`
|`HTTPS_KEYSTORE` | The name of the keystore file within the secret | `${KIE_SERVER_HTTPS_KEYSTORE}`
|`HTTPS_NAME` | The name associated with the server certificate | `${KIE_SERVER_HTTPS_NAME}`
|`HTTPS_PASSWORD` | The password for the keystore and certificate | `${KIE_SERVER_HTTPS_PASSWORD}`
|`JGROUPS_PING_PROTOCOL` | -- | openshift.DNS_PING
|`OPENSHIFT_DNS_PING_SERVICE_NAME` | -- | `${APPLICATION_NAME}-kieserver-2-ping`
|`OPENSHIFT_DNS_PING_SERVICE_PORT` | -- | 8888
|`SSO_URL` | RH-SSO URL | `${SSO_URL}`
|`SSO_OPENIDCONNECT_DEPLOYMENTS` | -- | ROOT.war
|`SSO_REALM` | RH-SSO Realm name | `${SSO_REALM}`
|`SSO_SECRET` | KIE Server 2 RH-SSO Client Secret | `${KIE_SERVER2_SSO_SECRET}`
|`SSO_CLIENT` | KIE Server 2 RH-SSO Client name | `${KIE_SERVER2_SSO_CLIENT}`
|`SSO_USERNAME` | RH-SSO Realm Admin Username used to create the Client if it doesn't exist | `${SSO_USERNAME}`
|`SSO_PASSWORD` | RH-SSO Realm Admin Password used to create the Client | `${SSO_PASSWORD}`
|`SSO_DISABLE_SSL_CERTIFICATE_VALIDATION` | RH-SSO Disable SSL Certificate Validation | `${SSO_DISABLE_SSL_CERTIFICATE_VALIDATION}`
|`SSO_PRINCIPAL_ATTRIBUTE` | RH-SSO Principal Attribute to use as username. | `${SSO_PRINCIPAL_ATTRIBUTE}`
|`HOSTNAME_HTTP` | Custom hostname for http service route. Leave blank for default hostname, e.g.: <application-name>-kieserver-<project>.<default-domain-suffix> | `${KIE_SERVER2_HOSTNAME_HTTP}`
|`HOSTNAME_HTTPS` | Custom hostname for https service route.  Leave blank for default hostname, e.g.: secure-<application-name>-kieserver-<project>.<default-domain-suffix> | `${KIE_SERVER2_HOSTNAME_HTTPS}`
|`AUTH_LDAP_URL` | LDAP Endpoint to connect for authentication | `${AUTH_LDAP_URL}`
|`AUTH_LDAP_BIND_DN` | Bind DN used for authentication | `${AUTH_LDAP_BIND_DN}`
|`AUTH_LDAP_BIND_CREDENTIAL` | LDAP Credentials used for authentication | `${AUTH_LDAP_BIND_CREDENTIAL}`
|`AUTH_LDAP_JAAS_SECURITY_DOMAIN` | The JMX ObjectName of the JaasSecurityDomain used to decrypt the password. | `${AUTH_LDAP_JAAS_SECURITY_DOMAIN}`
|`AUTH_LDAP_BASE_CTX_DN` | LDAP Base DN of the top-level context to begin the user search. | `${AUTH_LDAP_BASE_CTX_DN}`
|`AUTH_LDAP_BASE_FILTER` | LDAP search filter used to locate the context of the user to authenticate. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. A common example for the search filter is (uid={0}). | `${AUTH_LDAP_BASE_FILTER}`
|`AUTH_LDAP_SEARCH_SCOPE` | The search scope to use. | `${AUTH_LDAP_SEARCH_SCOPE}`
|`AUTH_LDAP_SEARCH_TIME_LIMIT` | The timeout in milliseconds for user or role searches. | `${AUTH_LDAP_SEARCH_TIME_LIMIT}`
|`AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE` | The name of the attribute in the user entry that contains the DN of the user. This may be necessary if the DN of the user itself contains special characters, backslash for example, that prevent correct user mapping. If the attribute does not exist, the entry's DN is used. | `${AUTH_LDAP_DISTINGUISHED_NAME_ATTRIBUTE}`
|`AUTH_LDAP_PARSE_USERNAME` | A flag indicating if the DN is to be parsed for the username. If set to true, the DN is parsed for the username. If set to false the DN is not parsed for the username. This option is used together with usernameBeginString and usernameEndString. | `${AUTH_LDAP_PARSE_USERNAME}`
|`AUTH_LDAP_USERNAME_BEGIN_STRING` | Defines the String which is to be removed from the start of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_BEGIN_STRING}`
|`AUTH_LDAP_USERNAME_END_STRING` | Defines the String which is to be removed from the end of the DN to reveal the username. This option is used together with usernameEndString and only taken into account if parseUsername is set to true. | `${AUTH_LDAP_USERNAME_END_STRING}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_ID` | Name of the attribute containing the user roles. | `${AUTH_LDAP_ROLE_ATTRIBUTE_ID}`
|`AUTH_LDAP_ROLES_CTX_DN` | The fixed DN of the context to search for user roles. This is not the DN where the actual roles are, but the DN where the objects containing the user roles are. For example, in a Microsoft Active Directory server, this is the DN where the user account is. | `${AUTH_LDAP_ROLES_CTX_DN}`
|`AUTH_LDAP_ROLE_FILTER` | A search filter used to locate the roles associated with the authenticated user. The input username or userDN obtained from the login module callback is substituted into the filter anywhere a {0} expression is used. The authenticated userDN is substituted into the filter anywhere a {1} is used. An example search filter that matches on the input username is (member={0}). An alternative that matches on the authenticated userDN is (member={1}). | `${AUTH_LDAP_ROLE_FILTER}`
|`AUTH_LDAP_ROLE_RECURSION` | The number of levels of recursion the role search will go below a matching context. Disable recursion by setting this to 0. | `${AUTH_LDAP_ROLE_RECURSION}`
|`AUTH_LDAP_DEFAULT_ROLE` | A role included for all authenticated users | `${AUTH_LDAP_DEFAULT_ROLE}`
|`AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID` | Name of the attribute within the roleCtxDN context which contains the role name. If the roleAttributeIsDN property is set to true, this property is used to find the role object's name attribute. | `${AUTH_LDAP_ROLE_NAME_ATTRIBUTE_ID}`
|`AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN` | A flag indicating if the DN returned by a query contains the roleNameAttributeID. If set to true, the DN is checked for the roleNameAttributeID. If set to false, the DN is not checked for the roleNameAttributeID. This flag can improve the performance of LDAP queries. | `${AUTH_LDAP_PARSE_ROLE_NAME_FROM_DN}`
|`AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN` | Whether or not the roleAttributeID contains the fully-qualified DN of a role object. If false, the role name is taken from the value of the roleNameAttributeId attribute of the context name. Certain directory schemas, such as Microsoft Active Directory, require this attribute to be set to true. | `${AUTH_LDAP_ROLE_ATTRIBUTE_IS_DN}`
|`AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK` | If you are not using referrals, you can ignore this option. When using referrals, this option denotes the attribute name which contains users defined for a certain role, for example member, if the role object is inside the referral. Users are checked against the content of this attribute name. If this option is not set, the check will always fail, so role objects cannot be stored in a referral tree. | `${AUTH_LDAP_REFERRAL_USER_ATTRIBUTE_ID_TO_CHECK}`
|`AUTH_ROLE_MAPPER_ROLES_PROPERTIES` | When present, the RoleMapping Login Module will be configured to use the provided file. This property defines the fully-qualified file path and name of a properties file or resource which maps roles to replacement roles. The format is original_role=role1,role2,role3 | `${AUTH_ROLE_MAPPER_ROLES_PROPERTIES}`
|`AUTH_ROLE_MAPPER_REPLACE_ROLE` | Whether to add to the current roles, or replace the current roles with the mapped ones. Replaces if set to true. | `${AUTH_ROLE_MAPPER_REPLACE_ROLE}`
.4+| `${APPLICATION_NAME}-postgresql-2`
|`POSTGRESQL_USER` | KIE server PostgreSQL database username | `${KIE_SERVER_POSTGRESQL_USER}`
|`POSTGRESQL_PASSWORD` | KIE server PostgreSQL database password | `${KIE_SERVER_POSTGRESQL_PWD}`
|`POSTGRESQL_DATABASE` | KIE server PostgreSQL database name | `${KIE_SERVER_POSTGRESQL_DB}`
|`POSTGRESQL_MAX_PREPARED_TRANSACTIONS` | Allows the PostgreSQL to handle XA transactions. | `${POSTGRESQL_MAX_PREPARED_TRANSACTIONS}`
|=======================================================================



=====  Volumes

|=============
|Deployment |Name  | mountPath | Purpose | readOnly 

|`${APPLICATION_NAME}-rhpamcentrmon` | businesscentral-keystore-volume | `/etc/businesscentral-secret-volume` | ssl certs | True
|`${APPLICATION_NAME}-smartrouter` | `${APPLICATION_NAME}-smartrouter` | `/opt/rhpam-smartrouter/data` | -- | false
|`${APPLICATION_NAME}-kieserver-1` | kieserver-keystore-volume | `/etc/kieserver-secret-volume` | ssl certs | True
|`${APPLICATION_NAME}-postgresql-1` | `${APPLICATION_NAME}-postgresql-pvol` | `/var/lib/pgsql/data` | postgresql | false
|`${APPLICATION_NAME}-kieserver-2` | kieserver-keystore-volume | `/etc/kieserver-secret-volume` | ssl certs | True
|`${APPLICATION_NAME}-postgresql-2` | `${APPLICATION_NAME}-postgresql-pvol` | `/var/lib/pgsql/data` | postgresql | false
|=============


=== External Dependencies


==== Volume Claims

A `PersistentVolume` object is a storage resource in an OpenShift cluster. Storage is provisioned by an administrator
by creating `PersistentVolume` objects from sources such as GCE Persistent Disks, AWS Elastic Block Stores (EBS), and NFS mounts.
Refer to the https://access.redhat.com/documentation/en-us/openshift_container_platform/3.11/html/developer_guide/dev-guide-persistent-volumes[Openshift documentation] for
more information.

|=============
|Name | Access Mode

|`${APPLICATION_NAME}-postgresql-claim-1` | ReadWriteOnce
|`${APPLICATION_NAME}-postgresql-claim-2` | ReadWriteOnce
|`${APPLICATION_NAME}-smartrouter-claim` | ReadWriteMany
|`${APPLICATION_NAME}-rhpamcentr-claim` | ReadWriteMany
|=============




==== Secrets

This template requires the following secrets to be installed for the application to run.

businesscentral-app-secret
smartrouter-app-secret
kieserver-app-secret






",16165,True,3852.322186701296,median
"== Step-by-step Cloud Foundry migration

=== Preview
https://docs.google.com/presentation/d/e/2PACX-1vSsEHn8cJfz8oWIwwUhdULt7nZzz3bBLK7OqM8UInkZ0LbQBCpPdhMoxsYGPe_90h9OvCu7dFlAimMJ/pub?start=false&loop=false&delayms=3000[Click here] to
check out the slides by https://twitter.com/ciberkleid[Cora Iberkleid] where she
migrates a setup of applications to be compliant with Spring Cloud Pipelines.

=== Introduction

This tutorial covers refactoring applications to comply with, and take advantage of, Spring Cloud Pipelines.

We will use a simple 3-tier application as an example:

image::{cf-migration-root-docs}/use_case_logical.png[title=""Use Case - Logical View""]

At the end of this tutorial, it will be possible to instantly create a Concourse pipeline for each app and run successfully through a full lifecycle, from source code commit to production deployment, following the lifecycle stages for testing and deployment recommended by Spring Cloud Pipelines. The app code bases will be improved with organized test coverage, a contract-based API, and a versioned database schema, enabling Spring Cloud Pipelines to carry out stubbed testing and to ensure backward compatibility for API and database schema changes.

=== Sample application - initial state

The sample application is implemented using Spring Boot apps for the UI and service tiers, and MySQL for the database.

The apps are built using Maven and pushed manually to Cloud Foundry. They leverage the three Pivotal Spring Cloud Services: Config Server, Service Discovery, and Circuit Breaker Dashboard. Rabbit is used to propagate Config Server refresh triggers.

The source code for the two Spring Boot apps is stored on GitHub, as is the backing repo for Config Server.

image::{cf-migration-root-docs}/use_case_implementation.png[title=""Use Case - Implementation""]

=== Sample application - end state

Through this tutorial, we will be adding Concourse and JFrog Bintray to manage the application lifecycle.

We will also be refactoring the application to comply with Spring Cloud Pipelines requirements and recommendations, including adding/organizing tests and introducing database versioning using Flyway and API contracts using Spring Cloud Contract.

=== Tutorial - toolset

* *GitHub* - sample app source code and config repositories,  a sample stubrunner app repository, and the Spring Cloud Pipelines code base
- https://github.com/ciberkleid/greeting-ui[greeting-ui]
- https://github.com/ciberkleid/fortune-service[fortune-service]
- https://github.com/ciberkleid/app-config[app-config]
- https://github.com/spring-cloud-samples/cloudfoundry-stub-runner-boot[cloudfoundry-stub-runner-boot]
- https://github.com/spring-cloud/spring-cloud-pipelines[spring-cloud-pipelines]
* *Pivotal Web Services* - public hosted Cloud Foundry offering http://run.pivotal.io[free trial accounts] and including MySQL, Rabbit, and Pivotal Spring Cloud Services in the Marketplace
* *Concourse*
* *JFrog Bintray* - public hosted Maven repository offering free https://bintray.com/signup/oss[OSS accounts]
* *Client Tools* - on your local machine, you will need an IDE as well as the mvn, git, cf, and fly (Concourse) CLIs

=== Tutorial - overview

The migration steps are broken down into three stages:

. *Scaffolding*
- Minimal refactoring to comply with basic Spring Cloud Pipelines requirements.
- At the end of this stage, each app will have a corresponding pipeline on Concourse. The pipelines will successfully build the apps, store the artifacts in Bintray, tag the GitHub repositories, and deploy the apps to Test, Stage, and Prod spaces in Cloud Foundry.
. *Tests*
- Add/organize tests to comply with Spring Cloud Pipelines recommendations. Incorporate flyway for database schema versioning and initial data loading.
- At the end of this stage, the pipelines will trigger unit and integration tests during the Build stage, smoke tests in the Test environment, and end-to-end tests in the Stage environment. The pipelines will also ensure backward compatibility for the database, such that you can safely roll back the backend service app, even after the database schema has been updated.
. *Contracts*
- Incorporate Spring Cloud Contract to define the API between the UI and service apps and auto-generate tests and stubs.
- At the end of this stage, the pipelines will catch breaking API changes during the Build stage and ensure backward compatibility for the API, such that you can safely roll back the backend service (producer) app, even after an API change.

=== Tutorial - step-by-step

==== Prep: Before you begin

If you want to simply review the migration steps explained below, you can look at the various branches in the https://github.com/ciberkleid/greeting-ui[greeting-ui] and https://github.com/ciberkleid/fortune-service[fortune-service] repositories - there is a branch representing the end-state of each stage:

image::{cf-migration-root-docs}/github_branches.png[title=""GitHub Branches""]

If you want to use this tutorial as a hands-on lab, fork each of the following repositories:

- https://github.com/ciberkleid/greeting-ui[greeting-ui]
- https://github.com/ciberkleid/fortune-service[fortune-service]
- https://github.com/ciberkleid/app-config[app-config]

Then, create a new directory on your local machine. You may name it anything you like; we will refer to it as `$SCP_HOME` throughout this tutorial.

In `$SCP_HOME`, clone your forks of `greeting-ui` and `fortune-service`, as well as the following two repositories:

- https://github.com/spring-cloud-samples/cloudfoundry-stub-runner-boot[cloudfoundry-stub-runner-boot]
- https://github.com/spring-cloud/spring-cloud-pipelines[spring-cloud-pipelines]

Finally, create a directory called `$SCP_HOME/credentials`. Leave it empty for now.

==== Stage 1: Scaffolding

In this stage, we make minimal changes to satisfy basic Spring Cloud Pipelines requirements so that the apps can run through the entire pipeline without error. We make ""scaffolding"" changes only - no code changes.

The steps in this stage must be completed for both `greeting-ui` and `fortune-service`.

===== 1.1 Create GitHub branches

```bash
git branch version
git checkout -b sc-pipelines
```
Branch *version* is required to exist, though it can be created as an empty branch. It is used by Spring Coud Pipelines to generate a version number for each new pipeline execution.

Branch *sc-pipelines* is optional and can be named anything you wish. The intention is for you to use it as a  working branch for the changes suggested in this tutorial (hence we create it and also check it out).

===== 1.2 Add Maven wrapper

```bash
mvn -N io.takari:maven:wrapper
```
This commands adds 4 files to a project:

[source,bash]
----
.
├── mvnw
├── mvnw.cmd
└── .mvn
    └── wrapper
        ├── maven-wrapper.jar
        └── maven-wrapper.properties
----

Make sure all four files are tracked by Git. For example, you can add the following to the `.gitignore` file:
```
#Exceptions
!/mvnw
!/mvnw.cmd
!/.mvn/wrapper/maven-wrapper.jar
!/.mvn/wrapper/maven-wrapper.properties
```

===== 1.3 Create Bintray maven repo package

We are using Bintray as the maven repository. Bintray requires that a package exist before any app artifacts can be uploaded.

Log into the Bintray UI and create the packages as follows. You can use the `Import from GitHub` option to create these:

image::{cf-migration-root-docs}/bintray_packages.png[title=""Bintray Packages""]

===== 1.4 Configure distribution management using Bintray maven repo

Edit the app `pom.xml` files as follows. Make sure the Bintray URLs match the URLs of the corresponding packages created in the previous step. The values you use will be different from the example shown below.
```xml
<properties>
...
<distribution.management.release.id>bintray</distribution.management.release.id>
<distribution.management.release.url>https://api.bintray.com/maven/ciberkleid/maven-repo/fortune-service</distribution.management.release.url>
</properties>

...

<distributionManagement>
<repository>
<id>${distribution.management.release.id}</id>
<url>${distribution.management.release.url}</url>
</repository>
</distributionManagement>
```

Though not required by Spring Cloud Pipelines, it makes sense to also configure your local maven settings with the credentials to your Bintray maven repo. To do so, edit your maven settings file, usually `~/.m2/settings.xml`. If the file does not exist, create it.

Note that the `id` must match the id specified in the previous step. Also, make sure to use your username and API token (not account password) instead of the sample values shown below.
```xml
<?xml version=""1.0"" encoding=""UTF-8""?>
<settings>
  <servers>
    <server>
      <id>bintray</id>
      <username>ciberkleid</username>
      <password>my-super-secret-api-token</password>
   </server>
 </servers>
</settings>
```

===== 1.5 Push changes to GitHub

Push the above changes to GitHub. You should be pushing the following to each of the two app repos:

* 4 new maven wrapper files
* a modified .gitignore file
* a modified pom.xml

===== 1.6 Add Spring Cloud Pipelines credentials file
In `$SCP_HOME/credentials`, make two copies of the file `$SCP_HOME/spring-cloud-pipelines/concourse/credentials-sample-cf.yml`. Rename them as `credentials-fortune-service.yml` and `credentials-greeting-ui.yml`.

CAUTION: These files will contain credentials to you GitHub repo, your Bintray repo, and your Cloud Foundry foundation. Hence, we opt to put them in a separate directory. You may choose to store these files in a private git repo, but do not push them to a public repo.

Edit the git properties of each credentials file. Make sure to replace the sample values shown below as appropriate. For `tools-branch`, you may opt to use a fixed release (use v1.0.0.M8 or later for Cloud Foundry). Leave other values as they are, we will update those in later steps.
```yml
app-url: git@github.com:ciberkleid/fortune-service.git
app-branch: sc-pipelines
tools-scripts-url: https://github.com/spring-cloud/spring-cloud-pipelines.git
tools-branch: master
build-options: """"

github-private-key: |
  example -----BEGIN RSA PRIVATE KEY-----
  MIIJKQIBAAKCAgEAvwkL97vBllOSE39Wa5ppczT1cr5Blmkhadfoa1Va2/IBVyvk
  NJ9PqoTI+BahF2EgzweyiDSvKsstlTsG7QgiM9So8Voi2PlDOrXL6uOfCuAS/G8X
  ...
  -----END RSA PRIVATE KEY-----
git-email: ciberkleid@pivotal.io
git-name: Cora Iberkleid
```

Edit the maven repo properties of each credentials file. Make sure to replace the sample values shown below as appropriate. Bintray requires separate URLs for uploads and downloads. If you are using a different artifact repository, such as Artifactory or Nexus, and the repository URL is the same for uploads and downloads, then you do not need to set `repo-with-binaries-for-upload`.
```yml
m2-settings-repo-id: bintray
m2-settings-repo-username: ciberkleid
m2-settings-repo-password: my-super-secret-api-token

repo-with-binaries: https://ciberkleid@my-super-secret-api-token@dl.bintray.com/ciberkleid/maven-repo

repo-with-binaries-for-upload: https://api.bintray.com/maven/ciberkleid/maven-repo/fortune-service
```
===== 1.7 Set Concourse pipeline

At this point, all of the build jobs, which run on Concourse workers, will succeed.

To verify this, log in to your Concourse target and set the Concourse pipelines. Update the target name in the example below as appropriate.

```bash
# Set greeting-ui pipeline
fly -t myTarget set-pipeline -p greeting-ui -c ""${SCP_HOME}/spring-cloud-pipelines/concourse/pipeline.yml"" -l ""${SCP_HOME}/credentials/credentials-greeting-ui.yml"" -n

# Set fortune-service pipeline
fly -t myTarget set-pipeline -p fortune-service -c ""${SCP_HOME}/spring-cloud-pipelines/concourse/pipeline.yml"" -l ""${SCP_HOME}/credentials/credentials-fortune-service.yml"" -n
```

Log into the Concourse UI and unpause the pipelines. Start each. You should see that the build jobs all succeed.

image::{cf-migration-root-docs}/concourse_build_success.png[title=""Build Success""]

In addition, you will see a new dev/<version_number> tag in each GitHub repo, as well as the app jars uploaded into Bintray.

The test, stage, and prod jobs will fail because we have not yet added scaffolding for deployment to Cloud Foundry. We will do that next.

===== 1.8 Add Cloud Foundry manifest

If you are deploying to Cloud Foundry, you may already be routinely including manifest files with your apps. Our sample apps did not have manifest files, so we add them now.

In the `greeting-ui` repo, create a `manifest.yml` file as follows:
```yml
---
applications:
- name: greeting-ui
  timeout: 120
  services:
  - config-server
  - cloud-bus
  - service-registry
  - circuit-breaker-dashboard
  env:
    JAVA_OPTS: -Djava.security.egd=file:///dev/urandom
    TRUST_CERTS: api.run.pivotal.io
```

In the `fortune-service` repo, create a `manifest.yml` file as follows:
```yml
---
applications:
- name: fortune-service
  timeout: 120
  services:
  - fortune-db
  - config-server
  - cloud-bus
  - service-registry
  - circuit-breaker-dashboard
  env:
    JAVA_OPTS: -Djava.security.egd=file:///dev/urandom
    TRUST_CERTS: api.run.pivotal.io
```

The `TRUST_CERTS` variable is used by the Pivotal Spring Cloud Services (Config Server, Service Registry, and Circuit Breaker Dashboard), which we are using in this example. The value specified above assumes deployment to Pivotal Web Services. Update it accordingly if you are deploying to a different Cloud Foundry foundation, or you can leave it out altogether if you are replacing the Pivotal Spring Cloud Services with alternative implementations (e.g. deploying apps and exposing them as user-provided services).

You may add additional values to the manifest files if you wish, for example if additional values are useful for any manual deployment you may still want to do, or desirable in your Spring Cloud Pipelines deployment. For example, an alternative manifest.yml for `fortune-service` could be as follows:

```yml
---
applications:
- name: fortune-service
  timeout: 120
  instances: 3
  memory: 1024M
  buildpack: https://github.com/cloudfoundry/java-buildpack.git
  random-route: true
  path: ./target/fortune-service-0.0.1-SNAPSHOT.jar
  services:
  - fortune-db
  - config-server
  - cloud-bus
  - service-registry
  - circuit-breaker-dashboard
  env:
    SPRING_PROFILES_ACTIVE: someProfile
    JAVA_OPTS: -Djava.security.egd=file:///dev/urandom
    TRUST_CERTS: api.run.pivotal.io
```

Note that `random-route` and `path` are ignored by Spring Cloud Pipelines. `instances` is honored in stage and prod, but overridden with a value of 1 for test.

===== 1.9 Add Spring Cloud Pipelines manifest

The Cloud Foundry manifest created in the previous step includes the logical names of the services to which the apps should be bound, but it does describe how the services can be provisioned. Hence, we add a second manifest file so that Spring Cloud Pipelines can provision the services.

Add a file called `sc-pipelines.yml` to each app, and include the same list of services as in the corresponding `manifest.yml`. Add the necessary details such that Spring Cloud Pipelines can construct a `cf create-service` command.

NOTE: The `type: broker' parameter shown below instructs Spring Cloud Pipelines to provision a service using `cf create-service'. Other service types are also supported: cups, syslog, route, app, and stubrunner.

More specifically, for `greeting-ui`, create an `sc-pipelines.yml` file with the following content:

```yml
test:
  services:
    - name: config-server
      type: broker
      broker: p-config-server
      plan: standard
      params:
        git:
          uri: https://github.com/ciberkleid/app-config
      useExisting: true
    - name: cloud-bus
      type: broker
      broker: cloudamqp
      plan: lemur
      useExisting: true
    - name: service-registry
      type: broker
      broker: p-service-registry
      plan: standard
      useExisting: true
    - name: circuit-breaker-dashboard
      type: broker
      broker: p-circuit-breaker-dashboard
      plan: standard
      useExisting: true
```

The `sc-pipelines.yml` file for `fortune-service` is similar, with the addition of the `fortune-db` service:
```yml
test:
  # list of required services
  services:
    - name: fortune-db
      type: broker
      broker: cleardb
      plan: spark
      useExisting: true
    - name: config-server
      type: broker
      broker: p-config-server
      plan: standard
      params:
        git:
          uri: https://github.com/ciberkleid/app-config
      useExisting: true
    - name: cloud-bus
      type: broker
      broker: cloudamqp
      plan: lemur
      useExisting: true
    - name: service-registry
      type: broker
      broker: p-service-registry
      plan: standard
      useExisting: true
    - name: circuit-breaker-dashboard
      type: broker
      broker: p-circuit-breaker-dashboard
      plan: standard
      useExisting: true
```

The values above assume deployment to Pivotal Web Services. If you are deploying to a different Cloud Foundry foundation, please update the values accordingly. Also, make sure to replace the `config-server` uri with the address of your fork of the https://github.com/ciberkleid/app-config[app-config] repo.

TIP: Notice the `useExisting: true` parameter above. By default, Spring Cloud Pipelines will delete and recreate services in the `test` space. To override this behavior and re-use existing services, we set `useExisting: true`. This is helpful in cases where services  may take time to provision and initialize, where there is no risk in re-using them between pipeline runs, or where it is desirable to retain the service instance from the last pipeline run (e.g. a database migration).

===== 1.10 Push changes to GitHub

Push the above changes to GitHub. You should be pushing the following to each of the two app repos:

* new app manifest file
* new sc-pipelines manifest file

===== 1.11 Create Cloud Foundry Orgs/Spaces

Spring Cloud Pipelines requires that the Cloud Foundry test, stage, and prod spaces exist before a pipeline is run. If you wish, you can use different foundations, orgs, and users for each. For simplicity, in this example, we use a single foundation (PWS), a single org, and a single user.


You can name the org(s) and spaces anything you like. Each app requires its own test space. The stage and prod spaces are shared.

For this example, create the following spaces:
```bash
cf create-space scp-test-greeting-ui
cf create-space scp-test-fortune-service
cf create-space scp-stage
cf create-space scp-prod
```

===== 1.12 Create Cloud Foundry stage and prod service instances

Spring Cloud Pipelines will dynamically create the services in the test spaces as per the `sc-pipelines.yml` file we created previously. Optionally, a second section can be added to the `sc-pipelines.yml` file for the stage environment, and these will be created dynamically as well. Prod services, however, must always be created manually.

For this example, we will create the stage and services manually.

Create the services listed in the app manifest files in both `scp-stage` and `scp-prod`.

===== 1.13 Update Spring Cloud Pipelines credentials file
Update the `greeting-ui` and `fortune-service` credentials files with Cloud Foundry information. Replace values in the example below as appropriate for your Cloud Foundry environment.

Notice that the space name specified is a prefix. Spring Cloud Pipelines will append the app name, matching the test space names created previously. The stage and prod space names are not prefixes and will not be altered by Spring Cloud Pipelines.

Note also the `paas-hostname-uuid`. The value will be included in each route created. This value is optional, but it is useful in shared/multi-tenant environments such as PWS, as it helps ensure routes are unique. Change it to a unique uuid of your choosing.

```yml
pipeline-descriptor: sc-pipelines.yml

paas-type: cf

paas-hostname-uuid: cyi

# test values
paas-test-api-url: https://api.run.pivotal.io
paas-test-username: ciberkleid@pivotal.io
paas-test-password: secret
paas-test-org: S1Pdemo12
paas-test-space-prefix: scp-test

# stage values
paas-stage-api-url: https://api.run.pivotal.io
paas-stage-username: ciberkleid@pivotal.io
paas-stage-password: my-super-secret-password
paas-stage-org: S1Pdemo12
paas-stage-space: scp-stage

# prod values
paas-prod-api-url: https://api.run.pivotal.io
paas-prod-username: ciberkleid@pivotal.io
paas-prod-password: my-super-secret-password
paas-prod-org: S1Pdemo12
paas-prod-space: scp-prod
```

===== 1.14 Update Concourse pipeline with updated credentials files

Set the Concourse pipelines again, as we did previously, to update them with the values added to the credentials files. The test, stage, and prod jobs will all now succeed.

image::{cf-migration-root-docs}/concourse_test_stage_prod_success.png[title=""Test, Stage, & Prod Success""]

On Cloud Foundry, you will now see the apps deployed in the test, stage, and prod spaces. The image below shows the deploymnet of `fortune-service` to its isolated and dedicated test space, with the 5 services declared in its manifest files (`sc-pipelines.yml` for provisioning, and `manifest.yml` for binding). It also shows the deployment of the same app to the shared prod space, including the stopped instance of the previous version. If a rollback were deemed necessary, the `prod-rollback` job in the pipeline could be triggered to remove the currently running version, remove the `prod/<version_number>` tag from GitHub, and re-start the former (*""venerable""*) version.

image::{cf-migration-root-docs}/cf_test_and_prod_deployed.png[title=""Cloud Foundry Test and Prod Deployment""]

===== Stage 1 Recap & next steps

What have we accomplished?

* By adding the basic scaffolding needed to enable Spring Cloud Pipelines to manage the lifecycle of `greeting-ui` and `fortune-service` from source code commit to production deploy, we have made it possible for the app dev teams to instantly and easily create pipelines for each app using a common, standardized template
* We can count on the pipelines to:
- automatically provision services in test spaces, and optionally in stage as well
- dynamically clean up the test spaces between pipeline executions
- upload the app artifacts to the maven repo (Bintray)
- tag the GitHub repositories with `dev/<version_number>` and `prod/<version_number>`
* After each successful pipeline run, we are in a position to roll back to the last deployed version using the `prod-rollback` job, if necessary

These accomplishments are extremely valuable, but in order to derive confidence and reliability from the pipelines, we need to incorporate testing. We do this in Stage 2 of the app migration.

==== Stage 2: Tests

In this stage, we enable Spring Cloud Pipelines to execute tests so that we can increase confidence in the code being deployed. We do so by adding test profiles to the pom.xml files, and then organizing and/or adding tests in a way that corresponds to the profiles. By doing so, we are establishing standards around testing across development teams in the enterprise.

We will also enable database schema versioning in this stage, thereby providing the foundation for rollback testing during schema changes.

===== 2.1 Add Maven profiles

For both `greeting-ui` and `fortune-service`, add a `profiles` section to the `pom.xml` file, as shown below. Note that we are adding four profiles:

* default
** For unit and integration tests. Note that this profile includes all tests except those that will explicitly be called by the smoke and e2e profiles.
** Tests matching this profile will be executed during the build-and-upload job
* apicompatibility
** For ensuring backward compatibility in case of API changes. Note that this is not effective until Stage 3, when we will add contracts. However, we add this profile now to ensure the api-compatibility-check job does not execute other tests.
* smoke
** For tests to be run against the app deployed in the test space.
* e2e
** For tests to be run against the app deployed in the stage space.

```xml
  <profiles>
    <profile>
      <id>default</id>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <includes>
                <include>**/*Tests.java</include>
                <include>**/*Test.java</include>
              </includes>
              <excludes>
                <exclude>**/smoke/**</exclude>
                <exclude>**/e2e/**</exclude>
              </excludes>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
        </plugins>
      </build>
    </profile>
    <profile>
      <id>apicompatibility</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <includes>
                <include>**/contracttests/**/*Tests.java</include>
                <include>**/contracttests/**/*Test.java</include>
              </includes>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
    <profile>
      <id>smoke</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <includes>
                <include>smoke/**/*Tests.java</include>
                <include>smoke/**/*Test.java</include>
              </includes>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
    <profile>
      <id>e2e</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <includes>
                <include>e2e/**/*Tests.java</include>
                <include>e2e/**/*Test.java</include>
              </includes>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
```

===== 2.2 Add/organize tests

Next, we ensure that we have a matching test package structure in our apps:

image::{cf-migration-root-docs}/test_package_structure.png[title=""Test Package Structure""]

Note that we are creating matching packages for the default, smoke, and e2e profiles only. We will address the package for the apicompatibility profile in Stage 3.

When working with your own apps, if you have existing tests, you would now move them into one of these packages now, and rename them so that they are included in the filters declared in the profiles (i.e. the file names end in `Test.java` or `Tests.java`)

In the case of our sample apps, there are no tests, so we add some now as follows.

*fortune-service default tests*

Add your unit and integration tests so that they match the default profile as defined in the `fortune-service` `pom.xml` file. These will be executed on Concourse against the `fortune-service` application running on the Concourse worker in the `build-and-upload` job.

As an example, we will add two tests, one that loads the context, and another that verifies the number of rows expected in the database:

```java
package io.pivotal;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import org.springframework.jdbc.core.JdbcTemplate;
import static org.assertj.core.api.Assertions.assertThat;

import static org.junit.Assert.*;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = FortuneServiceApplication.class)
public class FortuneServiceApplicationTests {

    @Test
    public void contextLoads() throws Exception {

    }

    @Autowired
    private JdbcTemplate template;

    @Test
    public void testDefaultSettings() throws Exception {
        assertThat(this.template.queryForObject(""SELECT COUNT(*) from FORTUNE"",
                Integer.class)).isEqualTo(7);
    }

}
```

*fortune-service smoke tests*

Add your smoke tests so that they match the smoke profile as defined in the `fortune-service` `pom.xml` file. These will be executed on Concourse against the `fortune-service` application deployed in the Cloud Foundry `scp-test-fortune-service` space. Two versions of these tests are executed against the app:

. the current version, in the `test-smoke` job
. the latest prod version, in the `test-rollback-smoke` job

image::{cf-migration-root-docs}/fortune_service_smoke_tests.png[title=""fortune-service Smoke Tests""]

In the test environment, we choose to verify that `fortune-service` is retrieving a fortune from `fortune-db`, and not returning its Hystrix fallback response:

```java
package smoke;

import org.assertj.core.api.BDDAssertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SmokeTests.class,
        webEnvironment = SpringBootTest.WebEnvironment.NONE)
@EnableAutoConfiguration
public class SmokeTests {

	@Value(""${application.url}"") String applicationUrl;

	RestTemplate restTemplate = new RestTemplate();

	@Test
	public void should_return_a_fortune() {
		ResponseEntity<String> response = this.restTemplate
				.getForEntity(""http://"" + this.applicationUrl + ""/"", String.class);

		BDDAssertions.then(response.getStatusCodeValue()).isEqualTo(200);

		// Filter out the known Hystrix fallback response
		BDDAssertions.then(response.getBody()).doesNotContain(""The fortuneteller will be back soon."");
	}

}
```

*fortune-service e2e tests*

Add your e2e tests so that they match the e2e profile as defined in the `fortune-service` `pom.xml` file. These will be executed on Concourse against the `fortune-service` application deployed in the Cloud Foundry `scp-stage` space. This space is shared, so we assume `greeting-ui` is also present.

image::{cf-migration-root-docs}/fortune_service_e2e_tests.png[title=""fortune-service E2E Tests""]

In the e2e environment, we choose to use a string replacement to obtain the URL for `greeting-ui`. We also choose to verify that we are hitting `fortune-db` and not receiving Hystrix fallback responses from either application:

```java
package e2e;

import org.assertj.core.api.BDDAssertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = E2eTests.class,
		webEnvironment = SpringBootTest.WebEnvironment.NONE)
@EnableAutoConfiguration
public class E2eTests {

	// The app is running in CF but the tests are executed from Concourse worker,
	// so the test will deduce the url to greeting-ui: it will assume the same host
	// as fortune-service, and simply replace ""fortune-service"" with ""greeting-ui"" in the url

	@Value(""${application.url}"") String applicationUrl;

	RestTemplate restTemplate = new RestTemplate();

	@Test
	public void should_return_a_fortune() {
		ResponseEntity<String> response = this.restTemplate
				.getForEntity(""http://"" + this.applicationUrl.replace(""fortune-service"", ""greeting-ui"") + ""/"", String.class);

		BDDAssertions.then(response.getStatusCodeValue()).isEqualTo(200);

		// Filter out the known Hystrix fallback responses from both fortune and greeting
		BDDAssertions.then(response.getBody()).doesNotContain(""This fortune is no good. Try another."").doesNotContain(""The fortuneteller will be back soon."");
	}

}
```

*greeting-ui default tests*

Add your unit and integration tests so that they match the default profile as defined in the `greeting-ui` `pom.xml` file. These will be executed on Concourse against the `greeting-ui` application running on the Concourse worker in the `build-and-upload` job.

As an example, we will add one test that loads the context:

```java
package io.pivotal;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = GreetingUIApplication.class)
public class GreetingUIApplicationTests {

    @Test
    public void contextLoads() throws Exception {

    }

}
```

*greeting-ui smoke tests*

Add your smoke tests so that they match the smoke profile as defined in the `greeting-ui` `pom.xml` file. These will be executed on Concourse against the `greeting-ui` application deployed in the Cloud Foundry `scp-test-greeting-ui` space. Two versions of these tests are executed against the app:

. the current version, in the `test-smoke` job
. the latest prod version, in the `test-rollback-smoke` job

image::{cf-migration-root-docs}/greeting_ui_smoke_tests.png[title=""greeting-ui Smoke Tests""]

Since `fortune-service` is not deployed to the `scp-test-greeting-ui` space, we expect to receive the Hystrix fallback response defined in `greeting-ui`. Hence, our smoke test validates that condition:
```java
package smoke;

import org.assertj.core.api.BDDAssertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SmokeTests.class,
        webEnvironment = SpringBootTest.WebEnvironment.NONE)
@EnableAutoConfiguration
public class SmokeTests {

    @Value(""${application.url}"") String applicationUrl;

    RestTemplate restTemplate = new RestTemplate();

    @Test
    public void should_return_a_fallback_fortune() {
        ResponseEntity<String> response = this.restTemplate
                .getForEntity(""http://"" + this.applicationUrl + ""/"", String.class);

        BDDAssertions.then(response.getStatusCodeValue()).isEqualTo(200);

        // Expect the hystrix fallback response
        BDDAssertions.then(response.getBody()).contains(""This fortune is no good. Try another."");
    }

}
```

*greeting-ui e2e tests*

Add your e2e tests so that they match the e2e profile as defined in the `greeting-ui` `pom.xml` file. These will be executed on Concourse against the `greeting-ui` application deployed in the Cloud Foundry `scp-stage` space. This space is shared, so we assume `fortune-service` is also present.

image::{cf-migration-root-docs}/greeting_ui_e2e_tests.png[title=""greeting-ui E2E Tests""]

In the e2e environment, we choose to verify that we are hitting `fortune-service` and not receiving the Hystrix fallback response from `greeting-ui`:

```java
package e2e;

import org.assertj.core.api.BDDAssertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = E2eTests.class,
		webEnvironment = SpringBootTest.WebEnvironment.NONE)
@EnableAutoConfiguration
public class E2eTests {

	@Value(""${application.url}"") String applicationUrl;

	RestTemplate restTemplate = new RestTemplate();

	@Test
	public void should_return_a_fortune() {
		ResponseEntity<String> response = this.restTemplate
				.getForEntity(""http://"" + this.applicationUrl + ""/"", String.class);

		BDDAssertions.then(response.getStatusCodeValue()).isEqualTo(200);

		// Filter out the known Hystrix fallback response
		BDDAssertions.then(response.getBody()).doesNotContain(""This fortune is no good. Try another."");
	}

}
```

===== 2.3 Enable database versioning

At this point will also incorporate https://flywaydb.org/[Flyway], an OSS database migration tool, to track database schema versions and handle schema changes and data loading.

This change only needs to be made to `fortune-service`, since `fortune-service` owns the interaction with `fortune-db`.

*Add Flyway dependency*

We first add the Flyway dependency to the `fortune-service` `pom.xml`. We need not add a version as Spring Boot will take care of that for us.

```xml
    <dependency>
      <groupId>org.flywaydb</groupId>
      <artifactId>flyway-core</artifactId>
    </dependency>
    <dependency>
```

*Create Flyway migration*

Next, we create a migration directory and our initial migration file following Flyway's file naming convention:

image::{cf-migration-root-docs}/fortune_service_flyway_file_name.png[title=""fortune-service Flyway File Name""]

Note the filename specifies the version (`V1`), followed by two underscore characters.

We place our CREATE TABLE and INSERT statements in our `src/main/resources/db/migration/V1__init.sql` file:

```sql
CREATE TABLE fortune (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  text varchar(255) not null
);

INSERT INTO fortune (text) VALUES ('Do what works.');

INSERT INTO fortune (text) VALUES ('Do the right thing.');

INSERT INTO fortune (text) VALUES ('Always be kind.');

INSERT INTO fortune (text) VALUES ('You learn from your mistakes... You will learn a lot today.');

INSERT INTO fortune (text) VALUES ('You can always find happiness at work on Friday.');

INSERT INTO fortune (text) VALUES ('You will be hungry again in one hour.');

INSERT INTO fortune (text) VALUES ('Today will be an awesome day!');
```
*Disable JPA DDL initialization*

Now that we are relying on Flyway to create and populate the schema, we need to disable JPA-based database initialization. We can set `ddl-auto` to `validate`, which will validate the schema against the application entities and throw an error in case of a mismatch, but not actually generate the schema:
```yml
spring:
  jpa:
    hibernate:
      ddl-auto: validate
```

There are a few options for where to store the `ddl-auto` configuration, both in terms of location (in the `fortune-service` app or on the `app-config` GitHub repo) and in terms of file name. For this example, update the `application.yml` in the `fortune-service` app for local testing. additionally, save these values in a new file called `application-flyway.yml` on your fork of https://github.com/ciberkleid/app-config[app-config].

By convention, `fortune-service` will pick up the configurations in `application-flyway.yml` if the string `flyway` is in the list of active Spring profiles. Thus, we add `flyway` to the environment variable `SPRING_PROFILES_ACTIVE` via the `fortune-service` `manifest.yml`:

```yml
---
applications:
- name: fortune-service
  timeout: 120
  services:
  - fortune-db
  - config-server
  - cloud-bus
  - service-registry
  - circuit-breaker-dashboard
  env:
    SPRING_PROFILES_ACTIVE: flyway
    JAVA_OPTS: -Djava.security.egd=file:///dev/urandom
    TRUST_CERTS: api.run.pivotal.io
```
*Remove non-Flyway data loading*

We can now remove the old code that populated the database. In our sample app, this was found in class `io.pivotal.FortuneServiceApplication`. The following shows the code we now remove:

```java
@Bean
    CommandLineRunner loadDatabase(FortuneRepository fortuneRepo) {
        return args -> {
//            logger.debug(""loading database.."");
//            fortuneRepo.save(new Fortune(1L, ""Do what works.""));
//            fortuneRepo.save(new Fortune(2L, ""Do the right thing.""));
//            fortuneRepo.save(new Fortune(3L, ""Always be kind.""));
//            fortuneRepo.save(new Fortune(4L, ""You learn from your mistakes... You will learn a lot today.""));
//            fortuneRepo.save(new Fortune(5L, ""You can always find happiness at work on Friday.""));
//            fortuneRepo.save(new Fortune(6L, ""You will be hungry again in one hour.""));
//            fortuneRepo.save(new Fortune(7L, ""Today will be an awesome day!""));
            logger.debug(""record count: {}"", fortuneRepo.count());
            fortuneRepo.findAll().forEach(x -> logger.debug(x.toString()));
        };

    }
```

We also no longer need the Fortune entity constructors, so we can comment these out in class `io.pivotal.fortune.Fortune` as shown below:
```java
//    public Fortune() {
//    }
//
//    public Fortune(Long id, String text) {
//        super();
//        this.id = id;
//        this.text = text;
//    }
```

*Flyway integration summary*

With that, we have completed the setup for Flyway and our database schema is now versioned. From this point onward, Spring Boot will call `Flyway.migrate()` to perform the database migration. As long as we follow Flyway conventions for future schema changes, Flyway will take care of tracking the schema version and migrating the database for us.

From a rollback perspective, Spring Cloud Pipelines includes two jobs in the `test` phase - `test-rollback-deploy` and `test-rollback-smoke` - wherein it validates that the latest prod jar works against the newly updated database. The purpose is to ensure that we can roll back the application in prod if a problem is discovered after the prod database schema has been updated, and avoid the burden of rolling back the database.

Read more about https://docs.spring.io/spring-boot/docs/current/reference/html/howto-database-initialization.html#howto-use-a-higher-level-database-migration-tool[Spring Boot database initialization with Flyway] for further information, including Flyway configuration options.

===== 2.4 Push changes to GitHub

For `greeting-ui`, you should be pushing the following new or modified files:

* pom.xml
* src/test/java/e2e/E2eTests.java
* src/test/java/io/pivotal/GreetingUIApplicationTests.java
* src/test/java/smoke/SmokeTests.java


For `fortune-service`, you should be pushing the following new or modified files:

* pom.xml
* src/test/java/e2e/E2eTests.java
* src/test/java/io/pivotal/FortuneServiceApplicationTests.java
* src/test/java/smoke/SmokeTests.java
* src/main/resources/db/migration/V1__init.sql
* src/main/resources/application.yml
* manifest.yml
* src/main/java/io/pivotal/FortuneServiceApplication.java
* src/main/java/io/pivotal/fortune/Fortune.java

For `app-config`, you should be pushing the following new or modified files:

* application-flyway.yml


===== 2.5 Re-run the pipelines

Run through the pipelines again and view the output for the jobs that run the default, smoke, and e2e tests. You will see that the tests we added in this stage were executed.

As you run through the pipelines a second time, you will see the smoke tests from the latest prod version run against the database in the `test-rollback-smoke` job. In this case there is no schema upgrade, but nonetheless the tests confirm that the latest prod version of the app can be used with the current database schema.

You can see the database version information stored in the database by Flyway either by querying the database itself or by hitting the flyway endpoint on the `fortune-service` URL. Here is an example from the scp-stage environment:

image::{cf-migration-root-docs}/fortune_service_flyway_schema_info.png[title=""fortune-service Flyway Schema Info""]

===== Stage 2 Recap & next steps

What have we accomplished?

* By integrating our applications with the testing strategy built into Spring Cloud Pipelines, we have increased the effectiveness of the pipelines, as well as our confidence in them
* Established a standard approach to organizing tests that will bring consistency within and across development teams
* Enabled auto-managed database versioning and backward compatibility testing that will alleviate database schema management throughout the release management lifecycle

We are now positioned to add any unit, integration, smoke, and end-to-end tests to our code base and extract a very high level of reliability and confidence from our pipelines. We are also better positioned to ensure that our dev teams conform to these practices, given the structure imposed by Spring Cloud Pipelines and the fast feedback and visibility we gain from the pipelines as they execute the tests.

However, we could benefit further by incorporating contracts to define and test the API integration points between applications. We do this in Stage 3 of the app migration.

==== Stage 3: Contracts

In this stage, we introduce contract-based programming practices into our sample application. Doing so improves API management capabilities, including defining, communicating, and testing API semantics. It also enables us to catch breaking API changes (i.e. validate API backward compatibility) in the build phase. This will extend the effectiveness of the pipelines, encourage better communication and programming practices across development teams, and provide faster feedback to developers.

We will integrate Spring Cloud Contract and add contracts, stubs, and a stub runner. We will also now complete and make use of the apicompatibility profile defined in Stage 2.

===== 3.1 Create a contract

Let's start by creating the contract for the interaction between `greeting-ui` and `fortune-service`. The contract should describe the following expectation:

* `greeting-ui` makes a `GET` request to the root URL of `fortune-service` and expects a response with status 200 and a string (""foo fortune"") in the body

We codify this using groovy syntax as follows:

```groovy
import org.springframework.cloud.contract.spec.Contract

Contract.make {
    description(""""""
should return a fortune string
"""""")
    request {
        method GET()
        url ""/""
    }
    response {
        status 200
        body ""foo fortune""
    }
}
```

Save this contract in the `fortune-service` code base in the following location, which is compliant with Spring Cloud Contract convention (`src/test/resources/contracts/<service-name>/<contract-file>`):

image::{cf-migration-root-docs}/fortune_service_contract_file.png[title=""fortune-service Flyway Contract File""]

NOTE: You can optionally enable your IDE to assist with contract syntax by adding the Spring Cloud Contract Verifier to your `pom.xml` file. It is pluggable, and includes groovy and pact by default.

```xml
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-contract-verifier</artifactId>
      <scope>test</scope>
    </dependency>
```

===== 3.2 Create a base class for contract tests

Now that we have a codified contract, we want to enable auto-generation of contract-based tests. The auto-generation, which we will configure in the next steps, requires a base class that stubs out the service that satisfies the API call, so that we can run the test without external dependencies (e.g. the DB). The objective is to focus on testing API semantics.

We create the base class in the `fortune-service` test package as follows:


```java
package io.pivotal.fortune;

import io.restassured.module.mockmvc.RestAssuredMockMvc;
import org.junit.Before;
import org.mockito.BDDMockito;

public class BaseClass {

    @Before
    public void setup() {
        FortuneService service = BDDMockito.mock(FortuneService.class);
        BDDMockito.given(service.getFortune()).willReturn(""foo fortune"");
        RestAssuredMockMvc.standaloneSetup(new FortuneController(service));
    }
}
```

===== 3.3 Enable automated contract-based testing

Now that we have a contract and a base class, we can use the *Spring Cloud Contract maven plugin* to auto-generate contract tests, stubs, and a stub jar.

First we add the Spring Cloud Contract version to the list of properties in the `fortune-service` `pom.xml` file, since we will reference it when we enable the Spring Cloud Contract maven plugin:

```xml
  <properties>
...
    <spring-cloud-contract.version>1.2.1.RELEASE</spring-cloud-contract.version>
...
</properties>
```

Next, we edit the `default` profile in the `fortune-service` `pom.xml` file as follows:

* Add a plugin block for Spring Cloud Contract maven plugin
* Configure it to use our base class (`io.pivotal.fortune.BaseClass`) to generate tests
* Configure it to place auto-generated tests in the test package `io.pivotal.fortune.contracttests`

Note that the package of the contracttests will be included by the `include` filter in the `default` profile, so these tests will be run against the app during the `build-and-upload` job. For `fortune-service`, this serves to validate that the app conforms to the contract.

Here is the complete profile:
```xml
    <profile>
      <id>default</id>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <includes>
                <include>**/*Tests.java</include>
                <include>**/*Test.java</include>
              </includes>
              <excludes>
                <exclude>**/smoke/**</exclude>
                <exclude>**/e2e/**</exclude>
              </excludes>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
          <!--Spring Cloud Contract maven plugin -->
          <plugin>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-contract-maven-plugin</artifactId>
            <version>${spring-cloud-contract.version}</version>
            <extensions>true</extensions>
            <configuration>
              <baseClassForTests>io.pivotal.fortune.BaseClass</baseClassForTests>
              <basePackageForTests>io.pivotal.fortune.contracttests</basePackageForTests>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
```

When the app is built, the Spring Cloud Contract maven plugin will also now produce a stub and a stub jar containing the contract and stub. This stub jar will be uploaded to Bintray, along with the usual app jar. As we will see shortly, this stub jar can be used by the `greeting-ui` dev team while they wait for `fortune-service` to be completed. Note that this gives the `greeting-ui` dev team a producer to test against that is based on a mutually agreed-upon contract without the lead time of having to wait for `fortune-service` to implement anything more than a base class, and without having to manually stub out calls to `fortune-service` based on arbitrary or static responses.

TIP: Package the project locally (run `mvn package`) to observe the tests, stubs, and stub jar that the Spring Cloud Contract maven plugin generates. See the image below for reference.

image::{cf-migration-root-docs}/fortune_service_generated_tests.png[title=""Generated Tests and Stubs""]

===== 3.4 Enable backward compatibility API check

To enable Spring Cloud Pipelines to catch any breaking API changes during the `build-api-compatibility-check` job, we add the Spring Cloud Contract maven plugin to the `apicompatibility` profile as well.

In this case, we want the plugin to generate tests based on contracts outside of the project (the ones from the latest prod version), so we configure the plugin to download the latest prod stub jar, which contains the old contract. The plugin will use the old contract and the specified base class, which in our example is the same as the one in the previous step, to generate contract tests. These tests are run against the new code to validate that it is still compatible with consumers complying with the prior contract. This ensures backward compatibility for the API.

In short, we edit the apicompatibility profile in the `fortune-service` `pom.xml` file as follows:

* Add a plugin block for Spring Cloud Contract maven plugin
* Configure it to download the latest prod stub jar from Bintray to obtain the old contract
* Configure it to use our base class (`io.pivotal.fortune.BaseClass`) to generate tests (we are using the same one as in the prrior step)
* Configure it to place auto-generated tests in the test package `io.pivotal.fortune.contracttests`

Note that the package of the contracttests matches the `include` filter in the `apicompatibility` profile, so these tests will be run against the app during the `build-api-compatibility-check` job. For `fortune-service`, this serves to validate that the app conforms to the old contract.

Here is the complete profile:

```xml
    <profile>
      <id>apicompatibility</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <includes>
                <include>**/contracttests/**/*Tests.java</include>
                <include>**/contracttests/**/*Test.java</include>
              </includes>
            </configuration>
          </plugin>
          <!--Spring Cloud Contract maven plugin -->
          <plugin>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-contract-maven-plugin</artifactId>
            <version>${spring-cloud-contract.version}</version>
            <extensions>true</extensions>
            <configuration>
              <contractsRepositoryUrl>${repo.with.binaries}</contractsRepositoryUrl>
              <contractDependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>${project.artifactId}</artifactId>
                <classifier>stubs</classifier>
                <version>${latest.production.version}</version>
              </contractDependency>
              <contractsPath>/</contractsPath>
              <baseClassForTests>io.pivotal.fortune.BaseClass</baseClassForTests>
              <basePackageForTests>io.pivotal.fortune.contracttests</basePackageForTests>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
```

The values for `${repo.with.binaries}` and `${latest.production.version}` will be injected dynamically by Spring Cloud Pipelines. You can run this locally by providing these values manually as system properties in the maven command.

===== 3.5 Push changes to GitHub

All changes in Stage 3 thus far are in `fortune-service`. At this point, you should be pushing the following new or modified files:

* pom.xml
* src/test/resources/contracts/greeting-ui/shouldReturnAFortune.groovy
* src/test/java/io/pivotal/fortune/BaseClass.java

===== 3.6 Re-run the fortune-service pipeline

Run through the `fortune-service` pipeline to generate stubs. The following output from the `build-and-upload` job shows the auto-generation of tests and stubs:

image::{cf-migration-root-docs}/fortune_service_build_and_upload_test_and_stub_generation.png[title=""fortune-service build-and-upload Test and Stub Generation""]

You will also see output in the `build-and-upload` job showing the execution of these tests against the code.

Additionally, you will see the stub jar uploaded to Bintray along with the usual app jar.

Finally, as you run through the pipeline a second time, you will see the contract tests from the latest prod version run against the new code in the output of the `build-api-compatibility-check` job. In this case there is no API change, but nonetheless the tests confirm that the latest prod version of the API can be used with the current code base.

===== 3.7 Enable stubs for integration tests

We are in the home stretch! Let's turn our attention to `greeting-ui`.

The following image compares the path of a request through `greeting-ui` in the build phase, both with and without stubs.

image::{cf-migration-root-docs}/greeting_ui_build_flow.png[title=""greeting-ui Build Flow""]

Without stubs, we expect the response to be the hystrix fallback response that is hard-coded in `greeting-ui`. With stubs, however, we can expect the response that was declared in the contract. In this case, the stubs are loaded into the `greeting-ui` process. This leads us to our next task: load the stubs produced by `fortune-service`.

*Enable in-process stub runner*

To load the stubs into the `greeting-ui` process, we must enable the Spring Cloud Contract Stub Runner dependency. This dependency will start an in-process stub runner that automatically configures Wiremock.

Add the following to the `greeting-ui` `pom.xml` file:

```xml
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
 <scope>test</scope>
</dependency>
```

*Add integration tests aligned with the contract*

Next, we add integration tests to `greeting-ui` that test for the expected response declared in the contract.

Add the following class to the test package in `greeting-ui`:

```java
package io.pivotal.fortune;

import io.pivotal.GreetingUIApplication;
import org.assertj.core.api.BDDAssertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cloud.contract.stubrunner.spring.AutoConfigureStubRunner;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = GreetingUIApplication.class, webEnvironment = SpringBootTest.WebEnvironment.NONE,
        properties = {""spring.application.name=greeting-ui"", ""spring.cloud.circuit.breaker.enabled=false"", ""hystrix.stream.queue.enabled=false""})
@AutoConfigureStubRunner(ids = {""io.pivotal:fortune-service:1.0.0.M1-20180102_203542-VERSION""},
        repositoryRoot = ""${REPO_WITH_BINARIES}""
        //workOffline = true
)

public class FortuneServiceTests {

    @Autowired FortuneService fortuneService;

    @Test
    public void shouldSendRequestToFortune() {
        // when
        String fortune = fortuneService.getFortune();
        // then
        BDDAssertions.then(fortune).isEqualTo(""foo fortune"");
    }

}
```

At this point, we can get through the build phase for `greeting-ui`, and the integration tests will be executed against the `fortune-service` stubs running in the `greeting-ui` process on the Concourse worker.

TIP: Notice the configuration of `@AutoConfigureStubRunner` - you can replace the version with a `+` sign if using Artifactory or Nexus and it will automatically choose the latest available version on the maven repo.

TIP: Setting `workOffline=true` (commented out but shown for informational purposes above) would make the stub runner get the stubs from the local maven repo. This is useful for local testing. Alternatively, set the `$REPO_WITH_BINARIES` environment variable to the value used in the credentials file before doing a local maven build, and the local build will download the stubs from your remote maven repo (e.g. Bintray).

===== 3.8 Enable stubs for smoke tests

The following image compares the path of a request through `greeting-ui` in the test phase, both with and without stubs. Note that in the build phase, where the app process is running on the Concourse worker, we ran the stubs in the same process. In the test environment (Cloud Foundry), we will run the stubs in a separate process using a standalone stub runner application.

image::{cf-migration-root-docs}/greeting_ui_test_flow.png[title=""greeting-ui Test Flow""]

As in the build phase, without stubs we expect the response to be the hystrix fallback response that is hard-coded in `greeting-ui`. With stubs, however, we can expect the response that was declared in the contract.

We will rely on Spring Cloud Pipelines to:

* Deploy a stub runner application
* Provide the stub runner application the necessary information to download the stubs
* Open a port on the stub runner application for each stub

We will rely on the stub runner application to:

* Download the stubs from our maven repo (Bintray)
* Expose each stub on a separate port
* Register each stub in the Service Discovery server

The following steps describe how to configure this.

*Provide standalone stub runner app jar*

In the Prep step for this tutorial, you cloned the https://github.com/spring-cloud-samples/cloudfoundry-stub-runner-boot[cloudfoundry-stub-runner-boot] repo to your local machine. The next step is to build this app and upload it to Bintray to make the jar available to Spring Cloud Pipelines.

As mentioned in Stage 1 of this tutorial, Bintray requires that a package exist before any app artifacts can be uploaded. Log into the Bintray UI and create a package for `cloudfoundry-stub-runner-boot`. If you forked this repo, you can use the `Import from GitHub` option. Otherwise, create the package manually and choose any license (e.g. Apache 2.0).

Now you are ready to build and upload this app to Bintray. The following script shows cloning, building and uploading. Edit as appropriate to match your Bintray URL, the Bintray ID in your `~/.m2/settings/xml` file, and the `cloudfoundry-stub-runner-boot` repo URL if you chose to fork it.

```bash
# Edit to match your Bintray URL and M2 repo ID setting (check your ~/.m2/settings.xml file)
MAVEN_REPO_URL=https://api.bintray.com/maven/ciberkleid/maven-repo/cloudfoundry-stub-runner-boot
MAVEN_REPO_ID=bintray

# Clone cloudfoundry-stub-runner-boot
git clone https://github.com/spring-cloud-samples/cloudfoundry-stub-runner-boot.git
cd cloudfoundry-stub-runner-boot

# Build and upload
./mvnw clean deploy -Ddistribution.management.release.url=""${MAVEN_REPO_URL}"" -Ddistribution.management.release.id=""${MAVEN_REPO_ID}""
```

You should now see the `cloudfoundry-stub-runner-boot` artifacts uploaded on Bintray.

*Provide standalone stub runner app manifest*

Next, we add a manifest file for the stub runner app for deployment to Cloud Foundry.

We will place this file in the `greeting-ui` repo. The file name and location can be your choice. For this example, we will use `sc-pipelines/manifest-stubrunner.yml`:

image::{cf-migration-root-docs}/greeting_ui_stubrunner_manifest.png[title=""greeting-ui Stub Runner Manifest""]

We populate this `manifest-stubrunner.yml` with the content shown below so that the stub runner binds to `service-registry`. The stub runner will register the `fortune-service` stub there so that `greeting-ui` can discover it in the same way it will discover the actual `fortune-service` app endpoint in stage and prod. From the `greeting-ui` perspective, there is no difference in how it interacts with Eureka and the stub runner app in test and the way it will interact with Eureka and the `fortune-service` app in stage and prod.

```yml
---
applications:
- name: stubrunner
  timeout: 120
  services:
  - service-registry
  env:
    JAVA_OPTS: -Djava.security.egd=file:///dev/urandom
    TRUST_CERTS: api.run.pivotal.io
```

*Provide stub runner jar and manifest info to the pipeline*

Now that we have a jar file and manifest file for our stub runner app, we need to provide this information to our `greeting-ui` pipeline so that the pipeline downloads the jar from Bintray and deploys it to Cloud Foundry. We do this through the `greeting-ui` `sc-pipelines.yml` file. We add an entry to the list of services in the `test` section, as follows:

```yml
    - name: stubrunner
      type: stubrunner
      coordinates: io.pivotal:cloudfoundry-stub-runner-boot:0.0.1.M1
      pathToManifest: sc-pipelines/manifest-stubrunner.yml
```

Notice that `name` matches the name of the app in `manifest-stubrunner.yml`, `coordinates` corresponds to the jar coordinates on the maven repo, and `pathToManifest` matches our chosen fie name for the stub runner app manifest.

Note also the `type` is set to `stubrunner`, which Spring Cloud Pipelines will recognize as a stanalone stub runner app and treat accordingly.

*Provide stub configuration for stub runner app*

The final steps in the configuration of the standalone stub runner app are:

* Enable the stub runner app to download the `fortune-service` stub from Bintray
* Open a second port on the container to receive requests for this stub

To accomplish this, we put stub and port configuration information into the properties section of the `greeting-ui` `pom.xml` file, using a property called `stubrunner.ids`. This property can accept a list of stubrunner ids, but for this tutorial, we only have one:

```xml
  <properties>
...
    <!--Tell stub runner app to start this stub-->
    <stubrunner.ids>io.pivotal:fortune-service:1.0.0.M1-20180102_203542-VERSION:stubs:10000</stubrunner.ids>
  </properties>
```

Spring Cloud Pipelines will use this information in two ways:

. It will provide this information to the stub runner app via the app's environment variables
- Spring Cloud Pipelines will aslo provide the `$REPO_WITH_BINARIES` as an env var for the stub runner app
- The stub runner app will use this information to download the stub from Bintray and expose it on the specified port
. It will open the additional port specified on the stub runner app and map a new route to it
- The format for each route will be `<stub-runner-app-name>-<hostname-uuid>-<env>-<app-name>-<port>.<domain>`
- In our example, this would be `stubrunner-cyi-test-greeting-ui-10000.cfapps.io`

Since we bound our stub runner app to `service-registry` (Eureka), the stub runner app will register the stub URL under the application name `FORTUNE-SERVICE` on Eureka:

image::{cf-migration-root-docs}/greeting_ui_stub_runner_eureka_registration.png[title=""greeting-ui Stub Runner Eureka Registration""]

This completes the process of configuring the standalone stub runner application.

NOTE: The port configuration may be automated by Spring Cloud Pipelines in the future, such that it will not be necessary to include the port in the `stubrunner.ids`, but for the moment, we are required to specify the port each stub should use.

*Edit smoke tests to align with the contract*

Finally, we edit our smoke tests for `greeting-ui` to ensure the response does *not* contain the hystrix fallback, since we are noe expecting a response from the stub.

```java
package smoke;

import org.assertj.core.api.BDDAssertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SmokeTests.class,
        webEnvironment = SpringBootTest.WebEnvironment.NONE)
@EnableAutoConfiguration
public class SmokeTests {

	@Value(""${application.url}"") String applicationUrl;

	RestTemplate restTemplate = new RestTemplate();

	@Test
	public void should_return_a_fortune() {
		ResponseEntity<String> response = this.restTemplate
				.getForEntity(""http://"" + this.applicationUrl + ""/"", String.class);

		BDDAssertions.then(response.getStatusCodeValue()).isEqualTo(200);

		// Filter out the known Hystrix fallback response
		BDDAssertions.then(response.getBody()).doesNotContain(""This fortune is no good. Try another."");
	}

}
```

In this case, in contrast to the integration test we created earlier for `greeting-ui`, we do not include `@AutoConfigureStubRunner` since we are using a standalone stub runner application.

===== 3.9 Push changes to GitHub

Push contract-based changes for `greeting-ui`. You should be pushing the following new or modified files:

* pom.xml
* sc-pipelines.yml
* sc-pipelines/manifest-stubrunner.yml
* src/test/java/io/pivotal/fortune/FortuneServiceTests.java
* src/test/java/smoke/SmokeTests.java

At this point, we can run through the full pipeline for `greeting-ui` and leverage the contract-based stub in both the build and test environments.

===== Stage 3 Recap

What have we accomplished?

By implementing a contract-driven approach with auto-generation of tests and stubs, we have introduced a clean, structured, and reliable way to define, communicate, document, manage and test APIs

* Inter-team communication will be simpler
- Consumer and producer teams can now communicate requirements through codified contracts
- The inventory of contracts serves as a record and reference for the agreed upon APIs
* Developer productivity will increase
- Producers can quickly and easily generate contract-based stubs
- Consumers no longer have to manually stub out APIs and write tests with arbitrary hard-coded responses - instead they can use the auto-generated stubs and test for contract-based responses
- Both producers and consumers can validate they are compliant with the contract
- Producers can verify backward compatibility of API changes
- Troubleshooting will be easier
- Failure and feedback will be faster


=== Conclusion

This concludes the tutorial on migrating apps for Spring Cloud Pipelines for Cloud Foundry.

Moving forward, the refactoring work needed here can be incorporated into your and/or your team's standard practices. In short:

*Good:*

* Use maven or gradle wrappers
* Include a Cloud Foundry manifest file in your app repo
* Include a pipeline descriptor (`sc-manifest.yml`) in your app repo
* Create an empty `version` branch in your app repo
* Include artifact repository configuration in the pom.xml file
* Align your Cloud Foundry spaces with Spring Cloud Pipelines model (isolated test space, shared stage and prod)

*Better*

* Include default, apicompatibility, smoke, and e2e profiles in the pom.xml file
* Organize tests accordingly in your app repo

*Best*

* Use a database migration tool like flyway
* Use contract-based API programming

Implementing all the *""good""* practices above already positions you to instantly create pipelines for your apps usign Spring Cloud Pipelines. This is a huge win in terms of consistency and productivity, and standardization across development teams. Of course, this is an open source project, so it can be modified to meet your needs.

Implementing the *""better""* practices will ensure the proper tests get run at the proper time. At that point you can add as much test coverage as you need to have high confidence in your pipelines.

Implementing the *""best""* practices will give you additional confidence in your pipeline and encourage better programming practices for database version and API management across development teams. It will also give you higher confidence in your pipelines and enable you to avoid the cumbersome business of rolling back a database.

Happy coding!
",16209,True,2809.4026583994482,median
"/**
 * BigInteger
 * 
 * An ActionScript 3 implementation of BigInteger (light version)
 * Copyright (c) 2007 Henri Torgemane
 * 
 * Derived from:
 * 		The jsbn library, Copyright (c) 2003-2005 Tom Wu
 * 
 * See LICENSE.txt for full license information.
 */
package com.hurlant.math
{

	import com.hurlant.crypto.prng.Random;
	import com.hurlant.util.Hex;
	import com.hurlant.util.Memory;
	
	import flash.utils.ByteArray;
	use namespace bi_internal;

	public class BigInteger
	{
		public static const DB:int = 30; // number of significant bits per chunk
		public static const DV:int = (1<<DB);
		public static const DM:int = (DV-1); // Max value in a chunk
		
		public static const BI_FP:int = 52;
		public static const FV:Number = Math.pow(2, BI_FP);
		public static const F1:int = BI_FP - DB;
		public static const F2:int = 2*DB - BI_FP;
		
		public static const ZERO:BigInteger = nbv(0);
		public static const ONE:BigInteger  = nbv(1);
		
		/*bi_internal */public var t:int; // number of chunks.
		bi_internal var s:int; // sign
		bi_internal var a:Array; // chunks
		
		/**
		 * 
		 * @param value
		 * @param radix  WARNING: If value is ByteArray, this holds the number of bytes to use.
		 * @param unsigned
		 * 
		 */
		public function BigInteger(value:* = null, radix:int = 0, unsigned:Boolean = false) {
			a = new Array;
			if (value is String) {
				if (radix&&radix!=16) throw new Error(""BigInteger construction with radix!=16 is not supported."");
				value = Hex.toArray(value);
				radix=0;
			}
			if (value is ByteArray) {
				var array:ByteArray = value as ByteArray;
				var length:int = radix || (array.length - array.position);
				fromArray(array, length, unsigned);
			}
		}
		public function dispose():void {
			var r:Random = new Random;
			for (var i:uint=0;i<a.length;i++) {
				a[i] = r.nextByte();
				delete a[i];
			}
			a=null;
			t=0;
			s=0;
			Memory.gc();
		}
		
		public function toString(radix:Number=16):String {
			if (s<0) return ""-""+negate().toString(radix);
			var k:int;
			switch (radix) {
				case 2:   k=1; break;
				case 4:   k=2; break;
				case 8:   k=3; break;
				case 16:  k=4; break;
				case 32:  k=5; break;
				default:
//					return toRadix(radix);
			}
			var km:int = (1<<k)-1;
			var d:int = 0;
			var m:Boolean = false;
			var r:String = """";
			var i:int = t;
			var p:int = DB-(i*DB)%k;
			if (i-- > 0) {
				if (p<DB && (d=a[i]>>p)>0) {
					m = true;
					r = d.toString(36);
				}
				while (i >= 0) {
					if (p<k) {
						d = (a[i]&((1<<p)-1))<<(k-p);
						d|= a[--i]>>(p+=DB-k);
					} else {
						d = (a[i]>>(p-=k))&km;
						if (p<=0) {
							p += DB;
							--i;
						}
					}
					if (d>0) {
						m = true;
					}
					if (m) {
						r += d.toString(36);
					}
				}
			}
			return m?r:""0"";
		}
		public function toArray(array:ByteArray):uint {
			const k:int = 8;
			const km:int = (1<<8)-1;
			var d:int = 0;
			var i:int = t;
			var p:int = DB-(i*DB)%k;
			var m:Boolean = false;
			var c:int = 0;
			if (i-- >0) {
				if (p<DB && (d=a[i]>>p)>0) {
					m = true;
					array.writeByte(d);
					c++;
				}
				while (i >= 0) {
					if (p<k) {
						d = (a[i]&((1<<p)-1))<<(k-p);
						d|= a[--i]>>(p+=DB-k);
					} else {
						d = (a[i]>>(p-=k))&km;
						if (p<=0) {
							p += DB;
							--i;
						}
					}
					if (d>0) {
						m = true;
					}
					if (m) {
						array.writeByte(d);
						c++;
					}
				}
			}
			return c;
		}
		/**
		 * best-effort attempt to fit into a Number.
		 * precision can be lost if it just can't fit.
		 */
		public function valueOf():Number {
			if (s==-1) {
				return -negate().valueOf();
			}
			var coef:Number = 1;
			var value:Number = 0;
			for (var i:uint=0;i<t;i++) {
				value += a[i]*coef;
				coef *= DV;
			}
			return value;
		}
		/**
		 * -this
		 */
		public function negate():BigInteger {
			var r:BigInteger = nbi();
			ZERO.subTo(this, r);
			return r;
		}
		/**
		 * |this|
		 */
		public function abs():BigInteger {
			return (s<0)?negate():this;
		}
		/**
		 * return + if this > v, - if this < v, 0 if equal
		 */
		public function compareTo(v:BigInteger):int {
			var r:int = s - v.s;
			if (r!=0) {
				return r;
			}
			var i:int = t;
			r = i-v.t;
			if (r!=0) {
				return r;
			}
			while (--i >=0) {
				r=a[i]-v.a[i];
				if (r != 0) return r;
			}
			return 0;
		}
		/**
		 * returns bit length of the integer x
		 */
		bi_internal function nbits(x:int):int {
			var r:int = 1;
			var t:int;
			if ((t=x>>>16) != 0) { x = t; r += 16; }
			if ((t=x>>8) != 0) { x = t; r += 8; }
			if ((t=x>>4) != 0) { x = t; r += 4; }
			if ((t=x>>2) != 0) { x = t; r += 2; }
			if ((t=x>>1) != 0) { x = t; r += 1; }
			return r;
		}
		/**
		 * returns the number of bits in this
		 */
		public function bitLength():int {
			if (t<=0) return 0;
			return DB*(t-1)+nbits(a[t-1]^(s&DM));
		}
		/**
		 * 
		 * @param v
		 * @return this % v
		 * 
		 */
		public function mod(v:BigInteger):BigInteger {
			var r:BigInteger = nbi();
			abs().divRemTo(v,null,r);
			if (s<0 && r.compareTo(ZERO)>0) {
				v.subTo(r,r);
			}
			return r;
		}
		/**
		 * this^e % m, 0 <= e < 2^32
		 */
		public function modPowInt(e:int, m:BigInteger):BigInteger {
			var z:IReduction;
			if (e<256 || m.isEven()) {
				z = new ClassicReduction(m);
			} else {
				z = new MontgomeryReduction(m);
			}
			return exp(e, z);
		}

		/**
		 * copy this to r
		 */
		bi_internal function copyTo(r:BigInteger):void {
			for (var i:int = t-1; i>=0; --i) {
				r.a[i] = a[i];
			}
			r.t = t;
			r.s = s;
		}
		/**
		 * set from integer value ""value"", -DV <= value < DV
		 */
		bi_internal function fromInt(value:int):void {
			t = 1;
			s = (value<0)?-1:0;
			if (value>0) {
				a[0] = value;
			} else if (value<-1) {
				a[0] = value+DV;
			} else {
				t = 0;
			}
		}
		/**
		 * set from ByteArray and length,
		 * starting a current position
		 * If length goes beyond the array, pad with zeroes.
		 */
		bi_internal function fromArray(value:ByteArray, length:int, unsigned:Boolean = false):void {
			var p:int = value.position;
			var i:int = p+length;
			var sh:int = 0;
			const k:int = 8;
			t = 0;
			s = 0;
			while (--i >= p) {
				var x:int = i<value.length?value[i]:0;
				if (sh == 0) {
					a[t++] = x;
				} else if (sh+k > DB) {
					a[t-1] |= (x&((1<<(DB-sh))-1))<<sh;
					a[t++] = x>>(DB-sh);
				} else {
					a[t-1] |= x<<sh;
				}
				sh += k;
				if (sh >= DB) sh -= DB;
			}
			if (!unsigned && (value[0]&0x80)==0x80) {
				s = -1;
				if (sh > 0) {
					a[t-1] |= ((1<<(DB-sh))-1)<<sh;
				}
			}
			clamp();
			value.position = Math.min(p+length,value.length);
		}
		/**
		 * clamp off excess high words
		 */
		bi_internal function clamp():void {
			var c:int = s&DM;
			while (t>0 && a[t-1]==c) {
				--t;
			}
		}
		/**
		 * r = this << n*DB
		 */
		bi_internal function dlShiftTo(n:int, r:BigInteger):void {
			var i:int;
			for (i=t-1; i>=0; --i) {
				r.a[i+n] = a[i];
			}
			for (i=n-1; i>=0; --i) {
				r.a[i] = 0;
			}
			r.t = t+n;
			r.s = s;
		}
		/**
		 * r = this >> n*DB
		 */
		bi_internal function drShiftTo(n:int, r:BigInteger):void {
			var i:int;
			for (i=n; i<t; ++i) {
				r.a[i-n] = a[i];
			}
			r.t = Math.max(t-n,0);
			r.s = s;
		}
		/**
		 * r = this << n
		 */
		bi_internal function lShiftTo(n:int, r:BigInteger):void {
			var bs:int = n%DB;
			var cbs:int = DB-bs;
			var bm:int = (1<<cbs)-1;
			var ds:int = n/DB;
			var c:int = (s<<bs)&DM;
			var i:int;
			for (i=t-1; i>=0; --i) {
				r.a[i+ds+1] = (a[i]>>cbs)|c;
				c = (a[i]&bm)<<bs;
			}
			for (i=ds-1; i>=0; --i) {
				r.a[i] = 0;
			}
			r.a[ds] = c;
			r.t = t+ds+1;
			r.s = s;
			r.clamp();
		}
		/**
		 * r = this >> n
		 */
		bi_internal function rShiftTo(n:int, r:BigInteger):void {
			r.s = s;
			var ds:int = n/DB;
			if (ds >= t) {
				r.t = 0;
				return;
			}
			var bs:int = n%DB;
			var cbs:int = DB-bs;
			var bm:int = (1<<bs)-1;
			r.a[0] = a[ds]>>bs;
			var i:int;
			for (i=ds+1; i<t; ++i) {
				r.a[i-ds-1] |= (a[i]&bm)<<cbs;
				r.a[i-ds] = a[i]>>bs;
			}
			if (bs>0) {
				r.a[t-ds-1] |= (s&bm)<<cbs;
			}
			r.t = t-ds;
			r.clamp();
		}
		/**
		 * r = this - v
		 */
		bi_internal function subTo(v:BigInteger, r:BigInteger):void {
			var i:int = 0;
			var c:int = 0;
			var m:int = Math.min(v.t, t);
			while (i<m) {
				c += a[i] - v.a[i];
				r.a[i++] = c & DM;
				c >>= DB;
			}
			if (v.t < t) {
				c -= v.s;
				while (i< t) {
					c+= a[i];
					r.a[i++] = c&DM;
					c >>= DB;
				}
				c += s;
			} else {
				c += s;
				while (i < v.t) {
					c -= v.a[i];
					r.a[i++] = c&DM;
					c >>= DB;
				}
				c -= v.s;
			}
			r.s = (c<0)?-1:0;
			if (c<-1) {
				r.a[i++] = DV+c;
			} else if (c>0) {
				r.a[i++] = c;
			}
			r.t = i;
			r.clamp();
		}
		/**
		 * am: Compute w_j += (x*this_i), propagates carries,
		 * c is initial carry, returns final carry.
		 * c < 3*dvalue, x < 2*dvalue, this_i < dvalue
		 */
		bi_internal function am(i:int,x:int,w:BigInteger,j:int,c:int,n:int):int {
			var xl:int = x&0x7fff;
			var xh:int = x>>15;
			while(--n >= 0) {
				var l:int = a[i]&0x7fff;
				var h:int = a[i++]>>15;
				var m:int = xh*l + h*xl;
				l = xl*l + ((m&0x7fff)<<15)+w.a[j]+(c&0x3fffffff);
				c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
				w.a[j++] = l&0x3fffffff;
			}
			return c;
		}
		/**
		 * r = this * v, r != this,a (HAC 14.12)
		 * ""this"" should be the larger one if appropriate
		 */
		bi_internal function multiplyTo(v:BigInteger, r:BigInteger):void {
			var x:BigInteger = abs();
			var y:BigInteger = v.abs();
			var i:int = x.t;
			r.t = i+y.t;
			while (--i >= 0) {
				r.a[i] = 0;
			}
			for (i=0; i<y.t; ++i) {
				r.a[i+x.t] = x.am(0, y.a[i], r, i, 0, x.t);
			}
			r.s = 0;
			r.clamp();
			if (s!=v.s) {
				ZERO.subTo(r, r);
			}
		}
		/**
		 * r = this^2, r != this (HAC 14.16)
		 */
		bi_internal function squareTo(r:BigInteger):void {
			var x:BigInteger = abs();
			var i:int = r.t = 2*x.t;
			while (--i>=0) r.a[i] = 0;
			for (i=0; i<x.t-1; ++i) {
				var c:int = x.am(i, x.a[i], r, 2*i, 0, 1);
				if ((r.a[i+x.t] += x.am(i+1, 2*x.a[i], r, 2*i+1, c, x.t-i-1)) >= DV) {
					r.a[i+x.t] -= DV;
					r.a[i+x.t+1] = 1;
				}
			}
			if (r.t>0) {
				r.a[r.t-1] += x.am(i, x.a[i], r, 2*i, 0, 1);
			}
			r.s = 0;
			r.clamp();
		}
		/**
		 * divide this by m, quotient and remainder to q, r (HAC 14.20)
		 * r != q, this != m. q or r may be null.
		 */
		bi_internal function divRemTo(m:BigInteger, q:BigInteger = null, r:BigInteger = null):void {
			var pm:BigInteger = m.abs();
			if (pm.t <= 0) return;
			var pt:BigInteger = abs();
			if (pt.t < pm.t) {
				if (q!=null) q.fromInt(0);
				if (r!=null) copyTo(r);
				return;
			}
			if (r==null) r = nbi();
			var y:BigInteger = nbi();
			var ts:int = s;
			var ms:int = m.s;
			var nsh:int = DB-nbits(pm.a[pm.t-1]); // normalize modulus
			if (nsh>0) {
				pm.lShiftTo(nsh, y);
				pt.lShiftTo(nsh, r);
			} else {
				pm.copyTo(y);
				pt.copyTo(r);
			}
			var ys:int = y.t;
			var y0:int = y.a[ys-1];
			if (y0==0) return;
			var yt:Number = y0*(1<<F1)+((ys>1)?y.a[ys-2]>>F2:0);
			var d1:Number = FV/yt;
			var d2:Number = (1<<F1)/yt;
			var e:Number = 1<<F2;
			var i:int = r.t;
			var j:int = i-ys;
			var t:BigInteger = (q==null)?nbi():q;
			y.dlShiftTo(j,t);
			if (r.compareTo(t)>=0) {
				r.a[r.t++] = 1;
				r.subTo(t,r);
			}
			ONE.dlShiftTo(ys,t);
			t.subTo(y,y); // ""negative"" y so we can replace sub with am later.
			while(y.t<ys) y.(y.t++, 0);
			while(--j >= 0) {
				// Estimate quotient digit
				var qd:int = (r.a[--i]==y0)?DM:Number(r.a[i])*d1+(Number(r.a[i-1])+e)*d2;
				if ((r.a[i]+= y.am(0, qd, r, j, 0, ys))<qd) { // Try it out
					y.dlShiftTo(j, t);
					r.subTo(t,r);
					while (r.a[i]<--qd) {
						r.subTo(t,r);
					}
				}
			}
			if (q!=null) {
				r.drShiftTo(ys,q);
				if (ts!=ms) {
					ZERO.subTo(q,q);
				}
			}
			r.t = ys;
			r.clamp();
			if (nsh>0) {
				r.rShiftTo(nsh, r); // Denormalize remainder
			}
			if (ts<0) {
				ZERO.subTo(r,r);
			}
		}
		/**
		 * return ""-1/this % 2^DB""; useful for Mont. reduction
		 * justification:
		 *         xy == 1 (mod n)
		 *         xy =  1+km
		 * 	 xy(2-xy) = (1+km)(1-km)
		 * x[y(2-xy)] =  1-k^2.m^2
		 * x[y(2-xy)] == 1 (mod m^2)
		 * if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
		 * should reduce x and y(2-xy) by m^2 at each step to keep size bounded
		 * [XXX unit test the living shit out of this.]
		 */
		bi_internal function invDigit():int {
			if (t<1) return 0;
			var x:int = a[0];
			if ((x&1)==0) return 0;
			var y:int = x&3; 							// y == 1/x mod 2^2
			y = (y*(2-(x&0xf )*y))             &0xf;	// y == 1/x mod 2^4
			y = (y*(2-(x&0xff)*y))             &0xff;	// y == 1/x mod 2^8
			y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff;	// y == 1/x mod 2^16
			// last step - calculate inverse mod DV directly;
			// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
			// XXX 48 bit ints? Whaaaa? is there an implicit float conversion in here?
			y = (y*(2-x*y%DV))%DV;	// y == 1/x mod 2^dbits
			// we really want the negative inverse, and -DV < y < DV
			return (y>0)?DV-y:-y;
		}
		/**
		 * true iff this is even
		 */
		bi_internal function isEven():Boolean {
			return ((t>0)?(a[0]&1):s) == 0;
		}
		/**
		 * this^e, e < 2^32, doing sqr and mul with ""r"" (HAC 14.79)
		 */
		bi_internal function exp(e:int, z:IReduction):BigInteger {
			if (e > 0xffffffff || e < 1) return ONE;
			var r:BigInteger = nbi();
			var r2:BigInteger = nbi();
			var g:BigInteger = z.convert(this);
			var i:int = nbits(e)-1;
			g.copyTo(r);
			while(--i>=0) {
				z.sqrTo(r, r2);
				if ((e&(1<<i))>0) {
					z.mulTo(r2,g,r);
				} else {
					var t:BigInteger = r;
					r = r2;
					r2 = t;
				}
				
			}
			return z.revert(r);
		}
		bi_internal function intAt(str:String, index:int):int {
			return parseInt(str.charAt(index), 36);
		}


		protected function nbi():* {
			return new BigInteger;
		}
		/**
		 * return bigint initialized to value
		 */
		public static function nbv(value:int):BigInteger {
			var bn:BigInteger = new BigInteger;
			bn.fromInt(value);
			return bn;
		}


		// Functions above are sufficient for RSA encryption.
		// The stuff below is useful for decryption and key generation

		public static const lowprimes:Array = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509];
		public static const lplim:int = (1<<26)/lowprimes[lowprimes.length-1];


		public function clone():BigInteger {
			var r:BigInteger = new BigInteger;
			this.copyTo(r);
			return r;
		}
		
		/**
		 * 
		 * @return value as integer
		 * 
		 */
		public function intValue():int {
			if (s<0) {
				if (t==1) {
					return a[0]-DV;
				} else if (t==0) {
					return -1;
				}
			} else if (t==1) {
				return a[0];
			} else if (t==0) {
				return 0;
			}
			// assumes 16 < DB < 32
			return  ((a[1]&((1<<(32-DB))-1))<<DB)|a[0];
		}
		
		/**
		 * 
		 * @return value as byte
		 * 
		 */
		public function byteValue():int {
			return (t==0)?s:(a[0]<<24)>>24;
		}
		
		/**
		 * 
		 * @return value as short (assumes DB>=16)
		 * 
		 */
		public function shortValue():int {
			return (t==0)?s:(a[0]<<16)>>16;
		}
		
		/**
		 * 
		 * @param r
		 * @return x s.t. r^x < DV
		 * 
		 */
		protected function chunkSize(r:Number):int {
			return Math.floor(Math.LN2*DB/Math.log(r));
		}
		
		/**
		 * 
		 * @return 0 if this ==0, 1 if this >0
		 * 
		 */
		public function sigNum():int {
			if (s<0) {
				return -1;
			} else if (t<=0 || (t==1 && a[0]<=0)) {
				return 0;
			} else{
				return 1;
			}
		}
		
		/**
		 * 
		 * @param b: radix to use
		 * @return a string representing the integer converted to the radix.
		 * 
		 */
		protected function toRadix(b:uint=10):String {
			if (sigNum()==0 || b<2 || b>32) return ""0"";
			var cs:int = chunkSize(b);
			var a:Number = Math.pow(b, cs);
			var d:BigInteger = nbv(a);
			var y:BigInteger = nbi();
			var z:BigInteger = nbi();
			var r:String = """";
			divRemTo(d, y, z);
			while (y.sigNum()>0) {
				r = (a+z.intValue()).toString(b).substr(1) + r;
				y.divRemTo(d,y,z);
			}
			return z.intValue().toString(b) + r;
		}
		
		/**
		 * 
		 * @param s a string to convert from using radix.
		 * @param b a radix
		 * 
		 */
		protected function fromRadix(s:String, b:int = 10):void {
			fromInt(0);
			var cs:int = chunkSize(b);
			var d:Number = Math.pow(b, cs);
			var mi:Boolean = false;
			var j:int = 0;
			var w:int = 0;
			for (var i:int=0;i<s.length;++i) {
				var x:int = intAt(s, i);
				if (x<0) {
					if (s.charAt(i) == ""-"" && sigNum() == 0) {
						mi = true;
					}
					continue;
				}
				w = b*w+x;
				if (++j >= cs) {
					dMultiply(d);
					dAddOffset(w,0);
					j=0;
					w=0;
				}
			}
			if (j>0) {
				dMultiply(Math.pow(b,j));
				dAddOffset(w,0);
			}
			if (mi) {
				BigInteger.ZERO.subTo(this, this);
			}
		}
		
		// XXX function fromNumber not written yet.
		
		/**
		 * 
		 * @return a byte array.
		 * 
		 */
		public function toByteArray():ByteArray {
			var i:int = t;
			var r:ByteArray = new ByteArray;
			r[0] = s;
			var p:int = DB-(i*DB)%8;
			var d:int;
			var k:int=0;
			if (i-- >0) {
				if (p<DB && (d=a[i]>>p)!=(s&DM)>>p) {
					r[k++] = d|(s<<(DB-p));
				}
				while (i>=0) {
					if(p<8) {
						d = (a[i]&((1<<p)-1))<<(8-p);
						d|= a[--i]>>(p+=DB-8);
					} else {
						d = (a[i]>>(p-=8))&0xff;
						if (p<=0) {
							p += DB;
							--i;
						}
					}
					if ((d&0x80)!=0) d|=-256;
					if (k==0 && (s&0x80)!=(d&0x80)) ++k;
					if (k>0 || d!=s) r[k++] = d;
				} 
			}
			return r;
		}

		public function equals(a:BigInteger):Boolean {
			return compareTo(a)==0;
		}
		public function min(a:BigInteger):BigInteger {
			return (compareTo(a)<0)?this:a;
		}
		public function max(a:BigInteger):BigInteger {
			return (compareTo(a)>0)?this:a;
		}
		
		/**
		 * 
		 * @param a	a BigInteger to perform the operation with
		 * @param op a Function implementing the operation
		 * @param r a BigInteger to store the result of the operation
		 * 
		 */
		protected function bitwiseTo(a:BigInteger, op:Function, r:BigInteger):void {
			var i:int;
			var f:int;
			var m:int = Math.min(a.t, t);
			for (i=0; i<m; ++i) {
				r.a[i] = op(this.a[i],a.a[i]);
			}
			if (a.t<t) {
				f = a.s&DM;
				for (i=m;i<t;++i) {
					r.a[i] = op(this.a[i],f);
				}
				r.t = t;
			} else {
				f = s&DM;
				for (i=m;i<a.t;++i) {
					r.a[i] = op(f,a.a[i]);
				}
				r.t = a.t;
			}
			r.s = op(s, a.s);
			r.clamp();
		}
		
		private function op_and(x:int, y:int):int {return x&y;}
		public function and(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			bitwiseTo(a, op_and, r);
			return r;
		}
		
		private function op_or(x:int, y:int):int {return x|y;}
		public function or(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			bitwiseTo(a, op_or, r);
			return r;
		}
		
		private function op_xor(x:int, y:int):int {return x^y;}
		public function xor(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			bitwiseTo(a, op_xor, r);
			return r;
		}
		
		private function op_andnot(x:int, y:int):int { return x&~y;}
		public function andNot(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			bitwiseTo(a, op_andnot, r);
			return r;
		}
		
		public function not():BigInteger {
			var r:BigInteger = new BigInteger;
			for (var i:int=0;i<t;++i) {
				r[i] = DM&~a[i];
			}
			r.t = t;
			r.s = ~s;
			return r;
		}
		
		public function shiftLeft(n:int):BigInteger {
			var r:BigInteger = new BigInteger;
			if (n<0) {
				rShiftTo(-n, r);
			} else {
				lShiftTo(n, r);
			}
			return r;
		}
		public function shiftRight(n:int):BigInteger {
			var r:BigInteger = new BigInteger;
			if (n<0) {
				lShiftTo(-n, r);
			} else {
				rShiftTo(n, r);
			}
			return r;
		}
		
		/**
		 * 
		 * @param x
		 * @return index of lowet 1-bit in x, x < 2^31
		 * 
		 */
		private function lbit(x:int):int {
			if (x==0) return -1;
			var r:int = 0;
			if ((x&0xffff)==0) { x>>= 16; r += 16; }
			if ((x&0xff) == 0) { x>>=  8; r +=  8; }
			if ((x&0xf)  == 0) { x>>=  4; r +=  4; }
			if ((x&0x3)  == 0) { x>>=  2; r +=  2; }
			if ((x&0x1)  == 0) ++r;
			return r;
		}
		
		/**
		 * 
		 * @return index of lowest 1-bit (or -1 if none)
		 * 
		 */
		public function getLowestSetBit():int {
			for (var i:int=0;i<t;++i) {
				if (a[i]!=0) return i*DB+lbit(a[i]);
			}
			if (s<0) return t*DB;
			return -1;
		}
		
		/**
		 * 
		 * @param x
		 * @return number of 1 bits in x
		 * 
		 */
		private function cbit(x:int):int {
			var r:uint =0;
			while (x!=0) { x &= x-1; ++r }
			return r;
		}
		
		/**
		 * 
		 * @return number of set bits
		 * 
		 */
		public function bitCount():int {
			var r:int=0;
			var x:int = s&DM;
			for (var i:int=0;i<t;++i) {
				r += cbit(a[i]^x);
			}
			return r;
		}
		
		/**
		 * 
		 * @param n
		 * @return true iff nth bit is set
		 * 
		 */
		public function testBit(n:int):Boolean {
			var j:int = Math.floor(n/DB);
			if (j>=t) {
				return s!=0;
			}
			return ((a[j]&(1<<(n%DB)))!=0);
		}
		
		/**
		 * 
		 * @param n
		 * @param op
		 * @return this op (1<<n)
		 * 
		 */
		protected function changeBit(n:int,op:Function):BigInteger {
			var r:BigInteger = BigInteger.ONE.shiftLeft(n);
			bitwiseTo(r, op, r);
			return r;
		}
		
		/**
		 * 
		 * @param n
		 * @return this | (1<<n)
		 * 
		 */
		public function setBit(n:int):BigInteger { return changeBit(n, op_or); }

		/**
		 * 
		 * @param n
		 * @return this & ~(1<<n)
		 * 
		 */
		public function clearBit(n:int):BigInteger { return changeBit(n, op_andnot); }

		/**
		 * 
		 * @param n
		 * @return this ^ (1<<n)
		 * 
		 */
		public function flipBit(n:int):BigInteger { return changeBit(n, op_xor); }

		/**
		 * 
		 * @param a
		 * @param r = this + a
		 * 
		 */
		protected function addTo(a:BigInteger, r:BigInteger):void {
			var i:int = 0;
			var c:int = 0;
			var m:int = Math.min(a.t, t);
			while (i<m) {
				c += this.a[i] + a.a[i];
				r.a[i++] = c&DM;
				c>>=DB;
			}
			if (a.t < t) {
				c += a.s;
				while (i<t) {
					c += this.a[i];
					r.a[i++] = c&DM;
					c >>= DB;
				}
				c += s;
			} else {
				c += s;
				while (i<a.t) {
					c += a.a[i];
					r.a[i++] = c&DM;
					c >>= DB;
				}
				c += a.s;
			}
			r.s = (c<0)?-1:0;
			if (c>0) {
				r.a[i++] = c;
			} else if (c<-1) {
				r.a[i++] = DV+c;
			}
			r.t = i;
			r.clamp();
		}
		
		/**
		 * 
		 * @param a
		 * @return this + a
		 * 
		 */
		public function add(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			addTo(a,r);
			return r;
		}

		/**
		 * 
		 * @param a
		 * @return this - a
		 * 
		 */
		public function subtract(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			subTo(a,r);
			return r;
		}
		
		/**
		 * 
		 * @param a
		 * @return this * a
		 * 
		 */
		public function multiply(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			multiplyTo(a,r);
			return r;
		}
		
		/**
		 * 
		 * @param a
		 * @return this / a
		 * 
		 */
		public function divide(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			divRemTo(a, r, null);
			return r;
		}
		
		public function remainder(a:BigInteger):BigInteger {
			var r:BigInteger = new BigInteger;
			divRemTo(a, null, r);
			return r;
		}
		
		/**
		 * 
		 * @param a
		 * @return [this/a, this%a]
		 * 
		 */
		public function divideAndRemainder(a:BigInteger):Array {
			var q:BigInteger = new BigInteger;
			var r:BigInteger = new BigInteger;
			divRemTo(a, q, r);
			return [q,r];
		}
		
		/**
		 * 
		 * this *= n, this >=0, 1 < n < DV
		 * 
		 * @param n
		 * 
		 */
		bi_internal function dMultiply(n:int):void {
			a[t] = am(0, n-1, this, 0, 0, t);
			++t;
			clamp();
		}
		
		/**
		 * 
		 * this += n << w words, this >= 0
		 * 
		 * @param n
		 * @param w
		 * 
		 */
		bi_internal function dAddOffset(n:int, w:int):void {
			while (t<=w) {
				a[t++] = 0;
			}
			a[w] += n;
			while (a[w] >= DV) {
				a[w] -= DV;
				if (++w >= t) {
					a[t++] = 0;
				}
				++a[w];
			}
		}

		/**
		 * 
		 * @param e
		 * @return this^e
		 * 
		 */
		public function pow(e:int):BigInteger {
			return exp(e, new NullReduction);
		}
		
		/**
		 * 
		 * @param a
		 * @param n
		 * @param r = lower n words of ""this * a"", a.t <= n
		 * 
		 */
		bi_internal function multiplyLowerTo(a:BigInteger, n:int, r:BigInteger):void {
			var i:int = Math.min(t+a.t, n);
			r.s = 0; // assumes a, this >= 0
			r.t = i;
			while (i>0) {
				r.a[--i]=0;
			}
			var j:int;
			for (j=r.t-t;i<j;++i) {
				r.a[i+t] = am(0, a.a[i], r, i, 0, t);
			}
			for (j=Math.min(a.t,n);i<j;++i) {
				am(0, a.a[i], r, i, 0, n-i);
			}
			r.clamp();
		}
		
		/**
		 * 
		 * @param a
		 * @param n
		 * @param r = ""this * a"" without lower n words, n > 0
		 * 
		 */
		bi_internal function multiplyUpperTo(a:BigInteger, n:int, r:BigInteger):void {
			--n;
			var i:int = r.t = t+a.t-n;
			r.s = 0; // assumes a,this >= 0
			while (--i>=0) {
				r.a[i] = 0;
			}
			for (i=Math.max(n-t,0);i<a.t;++i) {
				r.a[t+i-n] = am(n-i, a.a[i], r, 0, 0, t+i-n);
			}
			r.clamp();
			r.drShiftTo(1,r);
		}
		
		/**
		 * 
		 * @param e
		 * @param m
		 * @return this^e % m (HAC 14.85)
		 * 
		 */
		public function modPow(e:BigInteger, m:BigInteger):BigInteger {
			var i:int = e.bitLength();
			var k:int;
			var r:BigInteger = nbv(1);
			var z:IReduction;
			
			if (i<=0) {
				return r;
			} else if (i<18) {
				k=1;
			} else if (i<48) {
				k=3;
			} else if (i<144) {
				k=4;
			} else if (i<768) {
				k=5;
			} else {
				k=6;
			}
			if (i<8) {
				z = new ClassicReduction(m);
			} else if (m.isEven()) {
				z = new BarrettReduction(m);
			} else {
				z = new MontgomeryReduction(m);
			}
			// precomputation
			var g:Array = [];
			var n:int = 3;
			var k1:int = k-1;
			var km:int = (1<<k)-1;
			g[1] = z.convert(this);
			if (k > 1) {
				var g2:BigInteger = new BigInteger;
				z.sqrTo(g[1], g2);
				while (n<=km) {
					g[n] = new BigInteger;
					z.mulTo(g2, g[n-2], g[n]);
					n += 2;
				}
			}
			
			var j:int = e.t-1;
			var w:int;
			var is1:Boolean = true;
			var r2:BigInteger = new BigInteger;
			var t:BigInteger;
			i = nbits(e.a[j])-1;
			while (j>=0) {
				if (i>=k1) {
					w = (e.a[j]>>(i-k1))&km;
				} else {
					w = (e.a[j]&((1<<(i+1))-1))<<(k1-i);
					if (j>0) {
						w |= e.a[j-1]>>(DB+i-k1);
					}
				}
				n = k;
				while ((w&1)==0) {
					w >>= 1;
					--n;
				}
				if ((i -= n) <0) {
					i += DB;
					--j;
				}
				if (is1) { // ret == 1, don't bother squaring or multiplying it
					g[w].copyTo(r);
					is1 = false;
				} else {
					while (n>1) {
						z.sqrTo(r, r2);
						z.sqrTo(r2, r);
						n -= 2;
					}
					if (n>0) {
						z.sqrTo(r, r2);
					} else {
						t = r;
						r = r2;
						r2 = t;
					}
					z.mulTo(r2, g[w], r);
				}
				while (j>=0 && (e.a[j]&(1<<i)) == 0) {
					z.sqrTo(r, r2);
					t = r;
					r = r2;
					r2 = t;
					if (--i<0) {
						i = DB-1;
						--j;
					}
					
				}
			}
			return z.revert(r);
		}
		
		/**
		 * 
		 * @param a
		 * @return gcd(this, a) (HAC 14.54)
		 * 
		 */
		public function gcd(a:BigInteger):BigInteger {
			var x:BigInteger = (s<0)?negate():clone();
			var y:BigInteger = (a.s<0)?a.negate():a.clone();
			if (x.compareTo(y)<0) {
				var t:BigInteger=x;
				x=y;
				y=t;
			}
			var i:int = x.getLowestSetBit();
			var g:int = y.getLowestSetBit();
			if (g<0) return x;
			if (i<g) g= i;
			if (g>0) {
				x.rShiftTo(g, x);
				y.rShiftTo(g, y);
			}
			while (x.sigNum()>0) {
				if ((i = x.getLowestSetBit()) >0) {
					x.rShiftTo(i, x);
				}
				if ((i = y.getLowestSetBit()) >0) {
					y.rShiftTo(i, y);
				}
				if (x.compareTo(y) >= 0) {
					x.subTo(y, x);
					x.rShiftTo(1, x);
				} else {
					y.subTo(x, y);
					y.rShiftTo(1, y);
				}
			}
			if (g>0) {
				y.lShiftTo(g, y);
			}
			return y;
		}

		/**
		 * 
		 * @param n
		 * @return this % n, n < 2^DB
		 * 
		 */
		protected function modInt(n:int):int {
			if (n<=0) return 0;
			var d:int = DV%n;
			var r:int = (s<0)?n-1:0;
			if (t>0) {
				if (d==0) {
					r = a[0]%n;
				} else {
					for (var i:int=t-1;i>=0;--i) {
						r = (d*r+a[i])%n;
					}
				}
			}
			return r;
		}
		
		/**
		 * 
		 * @param m
		 * @return 1/this %m (HAC 14.61)
		 * 
		 */
		public function modInverse(m:BigInteger):BigInteger {
			var ac:Boolean = m.isEven();
			if ((isEven()&&ac) || m.sigNum()==0) {
				return BigInteger.ZERO;
			}
			var u:BigInteger = m.clone();
			var v:BigInteger = clone();
			var a:BigInteger = nbv(1);
			var b:BigInteger = nbv(0);
			var c:BigInteger = nbv(0);
			var d:BigInteger = nbv(1);
			while (u.sigNum()!=0) {
				while (u.isEven()) {
					u.rShiftTo(1,u);
					if (ac) {
						if (!a.isEven() || !b.isEven()) {
							a.addTo(this,a);
							b.subTo(m,b);
						}
						a.rShiftTo(1,a);
					} else if (!b.isEven()) {
						b.subTo(m,b);
					}
					b.rShiftTo(1,b);
				}
				while (v.isEven()) {
					v.rShiftTo(1,v);
					if (ac) {
						if (!c.isEven() || !d.isEven()) {
							c.addTo(this,c);
							d.subTo(m,d);
						}
						c.rShiftTo(1,c);
					} else if (!d.isEven()) {
						d.subTo(m,d);
					}
					d.rShiftTo(1,d);
				}
				if (u.compareTo(v)>=0) {
					u.subTo(v,u);
					if (ac) {
						a.subTo(c,a);
					}
					b.subTo(d,b);
				} else {
					v.subTo(u,v);
					if (ac) {
						c.subTo(a,c);
					}
					d.subTo(b,d);
				}
			}
			if (v.compareTo(BigInteger.ONE) != 0) {
				return BigInteger.ZERO;
			}
			if (d.compareTo(m) >= 0) {
				return d.subtract(m);
			}
			if (d.sigNum()<0) {
				d.addTo(m,d);
			} else {
				return d;
			}
			if (d.sigNum()<0) {
				return d.add(m);
			} else {
				return d;
			}
		}

		/**
		 * 
		 * @param t
		 * @return primality with certainty >= 1-.5^t
		 * 
		 */
		public function isProbablePrime(t:int):Boolean {
			var i:int;
			var x:BigInteger = abs();
			if (x.t == 1 && x.a[0]<=lowprimes[lowprimes.length-1]) {
				for (i=0;i<lowprimes.length;++i) {
					if (x[0]==lowprimes[i]) return true;
				}
				return false;
			}
			if (x.isEven()) return false;
			i = 1;
			while (i<lowprimes.length) {
				var m:int = lowprimes[i];
				var j:int = i+1;
				while (j<lowprimes.length && m<lplim) {
					m *= lowprimes[j++];
				}
				m = x.modInt(m);
				while (i<j) {
					if (m%lowprimes[i++]==0) {
						return false;
					}
				}
			}
			return x.millerRabin(t);
		}
		
		/**
		 * 
		 * @param t
		 * @return true if probably prime (HAC 4.24, Miller-Rabin)
		 * 
		 */
		protected function millerRabin(t:int):Boolean {
			var n1:BigInteger = subtract(BigInteger.ONE);
			var k:int = n1.getLowestSetBit();
			if (k<=0) {
				return false;
			}
			var r:BigInteger = n1.shiftRight(k);
			t = (t+1)>>1;
			if (t>lowprimes.length) {
				t = lowprimes.length;
			}
			var a:BigInteger = new BigInteger;
			for (var i:int=0;i<t;++i) {
				a.fromInt(lowprimes[i]);
				var y:BigInteger = a.modPow(r, this);
				if (y.compareTo(BigInteger.ONE)!=0 && y.compareTo(n1)!=0) {
					var j:int = 1;
					while (j++<k && y.compareTo(n1)!=0) {
						y = y.modPowInt(2, this);
						if (y.compareTo(BigInteger.ONE)==0) {
							return false;
						}
					}
					if (y.compareTo(n1)!=0) {
						return false;
					}
				}
			}
			return true;
		}

		/**
		 * Tweak our BigInteger until it looks prime enough
		 * 
		 * @param bits
		 * @param t
		 * 
		 */
		public function primify(bits:int, t:int):void {
			if (!testBit(bits-1)) {	// force MSB set
				bitwiseTo(BigInteger.ONE.shiftLeft(bits-1), op_or, this);
			}
			if (isEven()) {
				dAddOffset(1,0);	// force odd
			}
			while (!isProbablePrime(t)) {
				dAddOffset(2,0);
				while(bitLength()>bits) subTo(BigInteger.ONE.shiftLeft(bits-1),this);
			}
		}

	}
}
",12291,True,2702.67073116827,median