/*
 * intl_alibaba_js
 * Copyright(c) 2006, Alibaba.com.
 * 
 * This code is licensed under BSD license. Use it as you wish, 
 * but keep this copyright intact.
 */

qs = new Querystring();
getParameter();

function Querystring(qs)
{ // optionally pass a querystring to parse
	this.params = new Object()
	this.get = Querystring_get

	if (qs == null)
		qs = location.search.substring(1, location.search.length)

	if (qs.length == 0)
		return

	// Turn <plus> back to <space>
	// See: http://www.w3.org/TR/REC-html40/interact/forms.html#h-17.13.4.1
	qs = qs.replace(/\+/g, ' ')
	var args = qs.split('&') // parse out name/value pairs separated via &

	// split out each name=value pair
	for (var i = 0; i < args.length; i++)
	{
		var value;
		var pair = args[i].split('=')
		var name = unescape(pair[0])

		if (pair.length == 2)
			value = unescape(pair[1])
		else
			value = name

		this.params[name] = value
	}
}

function Querystring_get(key, default_)
{
	// This silly looking line changes UNDEFINED to NULL
	if (default_ == null)
		default_ = null;

	var value = this.params[key]

	if (value == null)
		value = default_;

	return value
}

function getParameter()
{
	getid = qs.get("id");
}

var getid = parseInt(getid);

//alert(getid);
if (typeof YAHOO == "undefined")
{
	var YAHOO = {};
}
YAHOO.namespace = function()
{
	var a = arguments, o = null, i, j, d;

	for (i = 0; i < a.length; i = i + 1)
	{
		d = a[i].split(".");
		o = YAHOO;

		for (j = (d[0] == "YAHOO") ? 1 : 0; j < d.length; j = j + 1)
		{
			o[d[j]] = o[d[j]] || {};
			o = o[d[j]];
		}
	}
	return o;
};
YAHOO.log = function(msg, cat, src)
{
	var l = YAHOO.widget.Logger;

	if (l && l.log)
	{
		return l.log(msg, cat, src);
	}
	else
	{
		return false;
	}
};
YAHOO.register = function(name, mainClass, data)
{
	var mods = YAHOO.env.modules;

	if (!mods[name])
	{
		mods[name] =
		{
			versions: [],
			builds: []
		};
	}

	var m = mods[name], v = data.version, b = data.build, ls = YAHOO.env.listeners;
	m.name = name;
	m.version = v;
	m.build = b;
	m.versions.push(v);
	m.builds.push(b);
	m.mainClass = mainClass;

	for (var i = 0; i < ls.length; i = i + 1)
	{
		ls[i](m);
	}

	if (mainClass)
	{
		mainClass.VERSION = v;
		mainClass.BUILD = b;
	}
	else
	{
		YAHOO.log("mainClass is undefined for module " + name, "warn");
	}
};
YAHOO.env = YAHOO.env ||
{
	modules: [],
	listeners: []
};

YAHOO.env.getVersion = function(name)
{
	return YAHOO.env.modules[name] || null;
};
YAHOO.env.ua = function()
{
	var o =
	{
		ie: 0,
		opera: 0,
		gecko: 0,
		webkit: 0
	};

	var ua = navigator.userAgent, m;

	if ((/KHTML/).test(ua))
	{
		o.webkit = 1;
	}
	m = ua.match(/AppleWebKit\/([^\s]*)/);

	if (m && m[1])
	{
		o.webkit = parseFloat(m[1]);
	}

	if (!o.webkit)
	{
		m = ua.match(/Opera[\s\/]([^\s]*)/);

		if (m && m[1])
		{
			o.opera = parseFloat(m[1]);
		}
		else
		{
			m = ua.match(/MSIE\s([^;]*)/);

			if (m && m[1])
			{
				o.ie = parseFloat(m[1]);
			}
			else
			{
				m = ua.match(/Gecko\/([^\s]*)/);

				if (m)
				{
					o.gecko = 1;
					m = ua.match(/rv:([^\s\)]*)/);

					if (m && m[1])
					{
						o.gecko = parseFloat(m[1]);
					}
				}
			}
		}
	}
	return o;
}();
(function()
{
	YAHOO.namespace("util", "widget", "example");

	if (typeof YAHOO_config != "undefined")
	{
		var l = YAHOO_config.listener, ls = YAHOO.env.listeners, unique = true, i;

		if (l)
		{
			for (i = 0; i < ls.length; i = i + 1)
			{
				if (ls[i] == l)
				{
					unique = false;
					break;
				}
			}

			if (unique)
			{
				ls.push(l);
			}
		}
	}
})();
YAHOO.lang =
{
	isArray: function(o)
	{
		if (o)
		{
			var l = YAHOO.lang;
			return l.isNumber(o.length) && l.isFunction(o.splice) && !l.hasOwnProperty(o.length);
		}
		return false;
	},
	isBoolean: function(o)
	{
		return typeof o === 'boolean';
	},
	isFunction: function(o)
	{
		return typeof o === 'function';
	},
	isNull: function(o)
	{
		return o === null;
	},
	isNumber: function(o)
	{
		return typeof o === 'number' && isFinite(o);
	},
	isObject: function(o)
	{
		return (o && ( typeof o === 'object' || YAHOO.lang.isFunction(o))) || false;
	},
	isString: function(o)
	{
		return typeof o === 'string';
	},
	isUndefined: function(o)
	{
		return typeof o === 'undefined';
	},
	hasOwnProperty: function(o, prop)
	{
		if (Object.prototype.hasOwnProperty)
		{
			return o.hasOwnProperty(prop);
		}
		return !YAHOO.lang.isUndefined(o[prop]) && o.constructor.prototype[prop] !== o[prop];
	},
	_IEEnumFix: function(r, s)
	{
		if (YAHOO.env.ua.ie)
		{
			var add = ["toString", "valueOf"];

			for (i = 0; i < add.length; i = i + 1)
			{
				var fname = add[i], f = s[fname];

				if (YAHOO.lang.isFunction(f) && f != Object.prototype[fname])
				{
					r[fname] = f;
				}
			}
		}
	},
	extend: function(subc, superc, overrides)
	{
		if (!superc || !subc)
		{
			throw new Error("YAHOO.lang.extend failed, please check that " + "all dependencies are included.");
		}

		var F = function()
		{
		};

		F.prototype = superc.prototype;
		subc.prototype = new F();
		subc.prototype.constructor = subc;
		subc.superclass = superc.prototype;

		if (superc.prototype.constructor == Object.prototype.constructor)
		{
			superc.prototype.constructor = superc;
		}

		if (overrides)
		{
			for (var i in overrides)
			{
				subc.prototype[i] = overrides[i];
			}
			YAHOO.lang._IEEnumFix(subc.prototype, overrides);
		}
	},
	augmentObject: function(r, s)
	{
		if (!s || !r)
		{
			throw new Error("Absorb failed, verify dependencies.");
		}
		var a = arguments, i, p, override = a[2];

		if (override && override !== true)
		{
			for (i = 2; i < a.length; i = i + 1)
			{
				r[a[i]] = s[a[i]];
			}
		}
		else
		{
			for (p in s)
			{
				if (override || !r[p])
				{
					r[p] = s[p];
				}
			}
			YAHOO.lang._IEEnumFix(r, s);
		}
	},
	augmentProto: function(r, s)
	{
		if (!s || !r)
		{
			throw new Error("Augment failed, verify dependencies.");
		}
		var a = [r.prototype, s.prototype];

		for (var i = 2; i < arguments.length; i = i + 1)
		{
			a.push(arguments[i]);
		}
		YAHOO.lang.augmentObject.apply(this, a);
	},
	dump: function(o, d)
	{
		var l = YAHOO.lang, i, len, s = [], OBJ = "{...}", FUN = "f(){...}", COMMA = ', ', ARROW = ' => ';

		if (!l.isObject(o) || o instanceof Date || ("nodeType" in o && "tagName" in o))
		{
			return o;
		}
		else if (l.isFunction(o))
		{
			return FUN;
		}
		d = (l.isNumber(d)) ? d : 3;

		if (l.isArray(o))
		{
			s.push("[");

			for (i = 0, len = o.length; i < len; i = i + 1)
			{
				if (l.isObject(o[i]))
				{
					s.push((d > 0) ? l.dump(o[i], d - 1) : OBJ);
				}
				else
				{
					s.push(o[i]);
				}
				s.push(COMMA);
			}

			if (s.length > 1)
			{
				s.pop();
			}
			s.push("]");
		}
		else
		{
			s.push("{");

			for (i in o)
			{
				if (l.hasOwnProperty(o, i))
				{
					s.push(i + ARROW);

					if (l.isObject(o[i]))
					{
						s.push((d > 0) ? l.dump(o[i], d - 1) : OBJ);
					}
					else
					{
						s.push(o[i]);
					}
					s.push(COMMA);
				}
			}

			if (s.length > 1)
			{
				s.pop();
			}
			s.push("}");
		}
		return s.join("");
	},
	substitute: function(s, o, f)
	{
		var i, j, k, key, v, meta, l = YAHOO.lang, saved = [], token, DUMP = 'dump', SPACE = ' ', LBRACE = '{',
			RBRACE = '}';

		for (;;)
		{
			i = s.lastIndexOf(LBRACE);

			if (i < 0)
			{
				break;
			}
			j = s.indexOf(RBRACE, i);

			if (i + 1 >= j)
			{
				break;
			}
			token = s.substring(i + 1, j);
			key = token;
			meta = null;
			k = key.indexOf(SPACE);

			if (k > -1)
			{
				meta = key.substring(k + 1);
				key = key.substring(0, k);
			}
			v = o[key];

			if (f)
			{
				v = f(key, v, meta);
			}

			if (l.isObject(v))
			{
				if (l.isArray(v))
				{
					v = l.dump(v, parseInt(meta, 10));
				}
				else
				{
					meta = meta || "";
					var dump = meta.indexOf(DUMP);

					if (dump > -1)
					{
						meta = meta.substring(4);
					}

					if (v.toString === Object.prototype.toString || dump > -1)
					{
						v = l.dump(v, parseInt(meta, 10));
					}
					else
					{
						v = v.toString();
					}
				}
			}
			else if (!l.isString(v) && !l.isNumber(v))
			{
				v = "~-" + saved.length + "-~";
				saved[saved.length] = token;
			}
			s = s.substring(0, i) + v + s.substring(j + 1);
		}

		for (i = saved.length - 1; i >= 0; i = i - 1)
		{
			s = s.replace(new RegExp("~-" + i + "-~"), "{" + saved[i] + "}", "g");
		}
		return s;
	},
	trim: function(s)
	{
		try
		{
			return s.replace(/^\s+|\s+$/g, "");
		}
		catch (e)
		{
			return s;
		}
	},
	merge: function()
	{
		var o = {}, a = arguments, i;

		for (i = 0; i < a.length; i = i + 1)
		{
			YAHOO.lang.augmentObject(o, a[i], true);
		}
		return o;
	},
	isValue: function(o)
	{
		var l = YAHOO.lang;
		return (l.isObject(o) || l.isString(o) || l.isNumber(o) || l.isBoolean(o));
	}
};
YAHOO.util.Lang = YAHOO.lang;
YAHOO.lang.augment = YAHOO.lang.augmentProto;
YAHOO.augment = YAHOO.lang.augmentProto;
YAHOO.extend = YAHOO.lang.extend;
YAHOO.register("yahoo", YAHOO,
{
	version: "2.3.0",
	build: "442"
});

YAHOO.util.CustomEvent = function(type, oScope, silent, signature)
{
	this.type = type;
	this.scope = oScope || window;
	this.silent = silent;
	this.signature = signature || YAHOO.util.CustomEvent.LIST;
	this.subscribers = [];

	if (!this.silent)
	{
	}
	var onsubscribeType = "_YUICEOnSubscribe";

	if (type !== onsubscribeType)
	{
		this.subscribeEvent = new YAHOO.util.CustomEvent(onsubscribeType, this, true);
	}
};
YAHOO.util.CustomEvent.LIST = 0;
YAHOO.util.CustomEvent.FLAT = 1;
YAHOO.util.CustomEvent.prototype =
{
	subscribe: function(fn, obj, override)
	{
		if (!fn)
		{
			throw new Error("Invalid callback for subscriber to '" + this.type + "'");
		}

		if (this.subscribeEvent)
		{
			this.subscribeEvent.fire(fn, obj, override);
		}
		this.subscribers.push(new YAHOO.util.Subscriber(fn, obj, override));
	},
	unsubscribe: function(fn, obj)
	{
		if (!fn)
		{
			return this.unsubscribeAll();
		}
		var found = false;

		for (var i = 0, len = this.subscribers.length; i < len; ++i)
		{
			var s = this.subscribers[i];

			if (s && s.contains(fn, obj))
			{
				this._delete(i);
				found = true;
			}
		}
		return found;
	},
	fire: function()
	{
		var len = this.subscribers.length;

		if (!len && this.silent)
		{
			return true;
		}
		var args = [], ret = true, i, rebuild = false;

		for (i = 0; i < arguments.length; ++i)
		{
			args.push(arguments[i]);
		}
		var argslength = args.length;

		if (!this.silent)
		{
		}

		for (i = 0; i < len; ++i)
		{
			var s = this.subscribers[i];

			if (!s)
			{
				rebuild = true;
			}
			else
			{
				if (!this.silent)
				{
				}
				var scope = s.getScope(this.scope);

				if (this.signature == YAHOO.util.CustomEvent.FLAT)
				{
					var param = null;

					if (args.length > 0)
					{
						param = args[0];
					}
					ret = s.fn.call(scope, param, s.obj);
				}
				else
				{
					ret = s.fn.call(scope, this.type, args, s.obj);
				}

				if (false === ret)
				{
					if (!this.silent)
					{
					}
					return false;
				}
			}
		}

		if (rebuild)
		{
			var newlist = [], subs = this.subscribers;

			for (i = 0, len = subs.length; i < len; ++i)
			{
				s = subs[i];
				newlist.push(subs[i]);
			}
			this.subscribers = newlist;
		}
		return true;
	},
	unsubscribeAll: function()
	{
		for (var i = 0, len = this.subscribers.length; i < len; ++i)
		{
			this._delete(len - 1 - i);
		}
		this.subscribers = [];
		return i;
	},
	_delete: function(index)
	{
		var s = this.subscribers[index];

		if (s)
		{
			delete s.fn;
			delete s.obj;
		}
		this.subscribers[index] = null;
	},
	toString: function()
	{
		return "CustomEvent: " + "'" + this.type + "', " + "scope: " + this.scope;
	}
};
YAHOO.util.Subscriber = function(fn, obj, override)
{
	this.fn = fn;
	this.obj = YAHOO.lang.isUndefined(obj) ? null : obj;
	this.override = override;
};
YAHOO.util.Subscriber.prototype.getScope = function(defaultScope)
{
	if (this.override)
	{
		if (this.override === true)
		{
			return this.obj;
		}
		else
		{
			return this.override;
		}
	}
	return defaultScope;
};
YAHOO.util.Subscriber.prototype.contains = function(fn, obj)
{
	if (obj)
	{
		return (this.fn == fn && this.obj == obj);
	}
	else
	{
		return (this.fn == fn);
	}
};
YAHOO.util.Subscriber.prototype.toString = function()
{
	return "Subscriber { obj: " + this.obj + ", override: " + (this.override || "no") + " }";
};

if (!YAHOO.util.Event)
{
	YAHOO.util.Event = function()
	{
		var loadComplete = false;
		var DOMReady = false;
		var listeners = [];
		var unloadListeners = [];
		var legacyEvents = [];
		var legacyHandlers = [];
		var retryCount = 0;
		var onAvailStack = [];
		var legacyMap = [];
		var counter = 0;
		var webkitKeymap =
		{
			63232: 38,
			63233: 40,
			63234: 37,
			63235: 39
		};

		return {
			POLL_RETRYS: 4000,
			POLL_INTERVAL: 10,
			EL: 0,
			TYPE: 1,
			FN: 2,
			WFN: 3,
			OBJ: 3,
			ADJ_SCOPE: 4,
			lastError: null,
			isSafari: YAHOO.env.ua.webkit,
			webkit: YAHOO.env.ua.webkit,
			isIE: YAHOO.env.ua.ie,
			_interval: null,
			startInterval: function()
			{
				if (!this._interval)
				{
					var self = this;
					var callback = function()
					{
						self._tryPreloadAttach();
					};
					this._interval = setInterval(callback, this.POLL_INTERVAL);
				}
			},
			onAvailable: function(p_id, p_fn, p_obj, p_override)
			{
				onAvailStack.push(
				{
					id: p_id,
					fn: p_fn,
					obj: p_obj,
					override: p_override,
					checkReady: false
				});

				retryCount = this.POLL_RETRYS;
				this.startInterval();
			},
			onDOMReady: function(p_fn, p_obj, p_override)
			{
				if (DOMReady)
				{
					setTimeout(function()
					{
						var s = window;

						if (p_override)
						{
							if (p_override === true)
							{
								s = p_obj;
							}
							else
							{
								s = p_override;
							}
						}
						p_fn.call(s, "DOMReady", [], p_obj);
					}, 0);
				}
				else
				{
					this.DOMReadyEvent.subscribe(p_fn, p_obj, p_override);
				}
			},
			onContentReady: function(p_id, p_fn, p_obj, p_override)
			{
				onAvailStack.push(
				{
					id: p_id,
					fn: p_fn,
					obj: p_obj,
					override: p_override,
					checkReady: true
				});

				retryCount = this.POLL_RETRYS;
				this.startInterval();
			},
			addListener: function(el, sType, fn, obj, override)
			{
				if (!fn || !fn.call)
				{
					return false;
				}

				if (this._isValidCollection(el))
				{
					var ok = true;

					for (var i = 0, len = el.length; i < len; ++i)
					{
						ok = this.on(el[i], sType, fn, obj, override) && ok;
					}
					return ok;
				}
				else if (YAHOO.lang.isString(el))
				{
					var oEl = this.getEl(el);

					if (oEl)
					{
						el = oEl;
					}
					else
					{
						this.onAvailable(el, function()
						{
							YAHOO.util.Event.on(el, sType, fn, obj, override);
						});
						return true;
					}
				}

				if (!el)
				{
					return false;
				}

				if ("unload" == sType && obj !== this)
				{
					unloadListeners[unloadListeners.length] = [el, sType, fn, obj, override];
					return true;
				}
				var scope = el;

				if (override)
				{
					if (override === true)
					{
						scope = obj;
					}
					else
					{
						scope = override;
					}
				}
				var wrappedFn = function(e)
				{
					return fn.call(scope, YAHOO.util.Event.getEvent(e), obj);
				};
				var li = [el, sType, fn, wrappedFn, scope];
				var index = listeners.length;
				listeners[index] = li;

				if (this.useLegacyEvent(el, sType))
				{
					var legacyIndex = this.getLegacyIndex(el, sType);

					if (legacyIndex == -1 || el != legacyEvents[legacyIndex][0])
					{
						legacyIndex = legacyEvents.length;
						legacyMap[el.id + sType] = legacyIndex;
						legacyEvents[legacyIndex] = [el, sType, el["on" + sType]];
						legacyHandlers[legacyIndex] = [];
						el["on" + sType] = function(e)
						{
							YAHOO.util.Event.fireLegacyEvent(YAHOO.util.Event.getEvent(e), legacyIndex);
						};
					}
					legacyHandlers[legacyIndex].push(li);
				}
				else
				{
					try
					{
						this._simpleAdd(el, sType, wrappedFn, false);
					}
					catch (ex)
					{
						this.lastError = ex;
						this.removeListener(el, sType, fn);
						return false;
					}
				}
				return true;
			},
			fireLegacyEvent: function(e, legacyIndex)
			{
				var ok = true, le, lh, li, scope, ret;
				lh = legacyHandlers[legacyIndex];

				for (var i = 0, len = lh.length; i < len; ++i)
				{
					li = lh[i];

					if (li && li[this.WFN])
					{
						scope = li[this.ADJ_SCOPE];
						ret = li[this.WFN].call(scope, e);
						ok = (ok && ret);
					}
				}
				le = legacyEvents[legacyIndex];

				if (le && le[2])
				{
					le[2](e);
				}
				return ok;
			},
			getLegacyIndex: function(el, sType)
			{
				var key = this.generateId(el) + sType;

				if (typeof legacyMap[key] == "undefined")
				{
					return -1;
				}
				else
				{
					return legacyMap[key];
				}
			},
			useLegacyEvent: function(el, sType)
			{
				if (this.webkit && ("click" == sType || "dblclick" == sType))
				{
					var v = parseInt(this.webkit, 10);

					if (!isNaN(v) && v < 418)
					{
						return true;
					}
				}
				return false;
			},
			removeListener: function(el, sType, fn)
			{
				var i, len;

				if (typeof el == "string")
				{
					el = this.getEl(el);
				}
				else if (this._isValidCollection(el))
				{
					var ok = true;

					for (i = 0, len = el.length; i < len; ++i)
					{
						ok = (this.removeListener(el[i], sType, fn) && ok);
					}
					return ok;
				}

				if (!fn || !fn.call)
				{
					return this.purgeElement(el, false, sType);
				}

				if ("unload" == sType)
				{
					for (i = 0, len = unloadListeners.length; i < len; i++)
					{
						var li = unloadListeners[i];

						if (li && li[0] == el && li[1] == sType && li[2] == fn)
						{
							unloadListeners[i] = null;
							return true;
						}
					}
					return false;
				}
				var cacheItem = null;
				var index = arguments[3];

				if ("undefined" == typeof index)
				{
					index = this._getCacheIndex(el, sType, fn);
				}

				if (index >= 0)
				{
					cacheItem = listeners[index];
				}

				if (!el || !cacheItem)
				{
					return false;
				}

				if (this.useLegacyEvent(el, sType))
				{
					var legacyIndex = this.getLegacyIndex(el, sType);
					var llist = legacyHandlers[legacyIndex];

					if (llist)
					{
						for (i = 0, len = llist.length; i < len; ++i)
						{
							li = llist[i];

							if (li && li[this.EL] == el && li[this.TYPE] == sType && li[this.FN] == fn)
							{
								llist[i] = null;
								break;
							}
						}
					}
				}
				else
				{
					try
					{
						this._simpleRemove(el, sType, cacheItem[this.WFN], false);
					}
					catch (ex)
					{
						this.lastError = ex;
						return false;
					}
				}
				delete listeners[index][this.WFN];
				delete listeners[index][this.FN];
				listeners[index] = null;
				return true;
			},
			getTarget: function(ev, resolveTextNode)
			{
				var t = ev.target || ev.srcElement;
				return this.resolveTextNode(t);
			},
			resolveTextNode: function(node)
			{
				if (node && 3 == node.nodeType)
				{
					return node.parentNode;
				}
				else
				{
					return node;
				}
			},
			getPageX: function(ev)
			{
				var x = ev.pageX;

				if (!x && 0 !== x)
				{
					x = ev.clientX || 0;

					if (this.isIE)
					{
						x += this._getScrollLeft();
					}
				}
				return x;
			},
			getPageY: function(ev)
			{
				var y = ev.pageY;

				if (!y && 0 !== y)
				{
					y = ev.clientY || 0;

					if (this.isIE)
					{
						y += this._getScrollTop();
					}
				}
				return y;
			},
			getXY: function(ev)
			{
				return [this.getPageX(ev), this.getPageY(ev)];
			},
			getRelatedTarget: function(ev)
			{
				var t = ev.relatedTarget;

				if (!t)
				{
					if (ev.type == "mouseout")
					{
						t = ev.toElement;
					}
					else if (ev.type == "mouseover")
					{
						t = ev.fromElement;
					}
				}
				return this.resolveTextNode(t);
			},
			getTime: function(ev)
			{
				if (!ev.time)
				{
					var t = new Date().getTime();

					try
					{
						ev.time = t;
					}
					catch (ex)
					{
						this.lastError = ex;
						return t;
					}
				}
				return ev.time;
			},
			stopEvent: function(ev)
			{
				this.stopPropagation(ev);
				this.preventDefault(ev);
			},
			stopPropagation: function(ev)
			{
				if (ev.stopPropagation)
				{
					ev.stopPropagation();
				}
				else
				{
					ev.cancelBubble = true;
				}
			},
			preventDefault: function(ev)
			{
				if (ev.preventDefault)
				{
					ev.preventDefault();
				}
				else
				{
					ev.returnValue = false;
				}
			},
			getEvent: function(e)
			{
				var ev = e || window.event;

				if (!ev)
				{
					var c = this.getEvent.caller;

					while (c)
					{
						ev = c.arguments[0];

						if (ev && Event == ev.constructor)
						{
							break;
						}
						c = c.caller;
					}
				}
				return ev;
			},
			getCharCode: function(ev)
			{
				var code = ev.keyCode || ev.charCode || 0;

				if (YAHOO.env.ua.webkit && (code in webkitKeymap))
				{
					code = webkitKeymap[code];
				}
				return code;
			},
			_getCacheIndex: function(el, sType, fn)
			{
				for (var i = 0, len = listeners.length; i < len; ++i)
				{
					var li = listeners[i];

					if (li && li[this.FN] == fn && li[this.EL] == el && li[this.TYPE] == sType)
					{
						return i;
					}
				}
				return -1;
			},
			generateId: function(el)
			{
				var id = el.id;

				if (!id)
				{
					id = "yuievtautoid-" + counter;
					++counter;
					el.id = id;
				}
				return id;
			},
			_isValidCollection: function(o)
			{
				try
				{
					return (o && o.length
						&& typeof o != "string" && !o.tagName && !o.alert && typeof o[0] != "undefined");
				}
				catch (e)
				{
					return false;
				}
			},
			elCache: {},
			getEl: function(id)
			{
				return document.getElementById(id);
			},
			clearCache: function()
			{
			},
			DOMReadyEvent: new YAHOO.util.CustomEvent("DOMReady", this),
			_load: function(e)
			{
				if (!loadComplete)
				{
					loadComplete = true;
					var EU = YAHOO.util.Event;
					EU._ready();
					EU._tryPreloadAttach();
				}
			},
			_ready: function(e)
			{
				if (!DOMReady)
				{
					DOMReady = true;
					var EU = YAHOO.util.Event;
					EU.DOMReadyEvent.fire();
					EU._simpleRemove(document, "DOMContentLoaded", EU._ready);
				}
			},
			_tryPreloadAttach: function()
			{
				if (this.locked)
				{
					return false;
				}

				if (this.isIE)
				{
					if (!DOMReady)
					{
						this.startInterval();
						return false;
					}
				}
				this.locked = true;
				var tryAgain = !loadComplete;

				if (!tryAgain)
				{
					tryAgain = (retryCount > 0);
				}
				var notAvail = [];
				var executeItem = function(el, item)
				{
					var scope = el;

					if (item.override)
					{
						if (item.override === true)
						{
							scope = item.obj;
						}
						else
						{
							scope = item.override;
						}
					}
					item.fn.call(scope, item.obj);
				};
				var i, len, item, el;

				for (i = 0, len = onAvailStack.length; i < len; ++i)
				{
					item = onAvailStack[i];

					if (item && !item.checkReady)
					{
						el = this.getEl(item.id);

						if (el)
						{
							executeItem(el, item);
							onAvailStack[i] = null;
						}
						else
						{
							notAvail.push(item);
						}
					}
				}

				for (i = 0, len = onAvailStack.length; i < len; ++i)
				{
					item = onAvailStack[i];

					if (item && item.checkReady)
					{
						el = this.getEl(item.id);

						if (el)
						{
							if (loadComplete || el.nextSibling)
							{
								executeItem(el, item);
								onAvailStack[i] = null;
							}
						}
						else
						{
							notAvail.push(item);
						}
					}
				}
				retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;

				if (tryAgain)
				{
					this.startInterval();
				}
				else
				{
					clearInterval(this._interval);
					this._interval = null;
				}
				this.locked = false;
				return true;
			},
			purgeElement: function(el, recurse, sType)
			{
				var elListeners = this.getListeners(el, sType);

				if (elListeners)
				{
					for (var i = 0, len = elListeners.length; i < len; ++i)
					{
						var l = elListeners[i];
						this.removeListener(el, l.type, l.fn, l.index);
					}
				}

				if (recurse && el && el.childNodes)
				{
					for (i = 0, len = el.childNodes.length; i < len; ++i)
					{
						this.purgeElement(el.childNodes[i], recurse, sType);
					}
				}
			},
			getListeners: function(el, sType)
			{
				var results = [], searchLists;

				if (!sType)
				{
					searchLists = [listeners, unloadListeners];
				}
				else if (sType == "unload")
				{
					searchLists = [unloadListeners];
				}
				else
				{
					searchLists = [listeners];
				}

				for (var j = 0; j < searchLists.length; ++j)
				{
					var searchList = searchLists[j];

					if (searchList && searchList.length > 0)
					{
						for (var i = 0, len = searchList.length; i < len; ++i)
						{
							var l = searchList[i];

							if (l && l[this.EL] === el && (!sType || sType === l[this.TYPE]))
							{
								results.push(
								{
									type: l[this.TYPE],
									fn: l[this.FN],
									obj: l[this.OBJ],
									adjust: l[this.ADJ_SCOPE],
									index: i
								});
							}
						}
					}
				}

				return (results.length) ? results : null;
			},
			_unload: function(e)
			{
				var EU = YAHOO.util.Event, i, j, l, len, index;

				for (i = 0, len = unloadListeners.length; i < len; ++i)
				{
					l = unloadListeners[i];

					if (l)
					{
						var scope = window;

						if (l[EU.ADJ_SCOPE])
						{
							if (l[EU.ADJ_SCOPE] === true)
							{
								scope = l[EU.OBJ];
							}
							else
							{
								scope = l[EU.ADJ_SCOPE];
							}
						}
						l[EU.FN].call(scope, EU.getEvent(e), l[EU.OBJ]);
						unloadListeners[i] = null;
						l = null;
						scope = null;
					}
				}
				unloadListeners = null;

				if (listeners && listeners.length > 0)
				{
					j = listeners.length;

					while (j)
					{
						index = j - 1;
						l = listeners[index];

						if (l)
						{
							EU.removeListener(l[EU.EL], l[EU.TYPE], l[EU.FN], index);
						}
						j = j - 1;
					}
					l = null;
					EU.clearCache();
				}

				for (i = 0, len = legacyEvents.length; i < len; ++i)
				{
					legacyEvents[i][0] = null;
					legacyEvents[i] = null;
				}
				legacyEvents = null;
				EU._simpleRemove(window, "unload", EU._unload);
			},
			_getScrollLeft: function()
			{
				return this._getScroll()[1];
			},
			_getScrollTop: function()
			{
				return this._getScroll()[0];
			},
			_getScroll: function()
			{
				var dd = document.documentElement, db = document.body;

				if (dd && (dd.scrollTop || dd.scrollLeft))
				{
					return [dd.scrollTop, dd.scrollLeft];
				}
				else if (db)
				{
					return [db.scrollTop, db.scrollLeft];
				}
				else
				{
					return [0, 0];
				}
			},
			regCE: function()
			{
			},
			_simpleAdd: function()
			{
				if (window.addEventListener)
				{
					return function(el, sType, fn, capture)
					{
						el.addEventListener(sType, fn, (capture));
					};
				}
				else if (window.attachEvent)
				{
					return function(el, sType, fn, capture)
					{
						el.attachEvent("on" + sType, fn);
					};
				}
				else
				{
					return function()
					{
					};
				}
			}(),
			_simpleRemove: function()
			{
				if (window.removeEventListener)
				{
					return function(el, sType, fn, capture)
					{
						el.removeEventListener(sType, fn, (capture));
					};
				}
				else if (window.detachEvent)
				{
					return function(el, sType, fn)
					{
						el.detachEvent("on" + sType, fn);
					};
				}
				else
				{
					return function()
					{
					};
				}
			}()
		};
	}();

	(function()
	{
		var EU = YAHOO.util.Event;
		EU.on = EU.addListener;

		if (EU.isIE)
		{
			YAHOO.util.Event.onDOMReady(YAHOO.util.Event._tryPreloadAttach, YAHOO.util.Event, true);
			var el, d = document, b = d.body;

			if (("undefined" !== typeof YAHOO_config) && YAHOO_config.injecting)
			{
				el = document.createElement("script");
				var p = d.getElementsByTagName("head")[0] || b;
				p.insertBefore(el, p.firstChild);
			}
			else
			{
				d.write('<scr' + 'ipt id="_yui_eu_dr" defer="true"><' + '/script>');
				el = document.getElementById("_yui_eu_dr");
			}

			if (el)
			{
				el.onreadystatechange = function()
				{
					if ("complete" === this.readyState)
					{
						this.parentNode.removeChild(this);
						YAHOO.util.Event._ready();
					}
				};
			}
			else
			{
			}
			el = null;
		}
		else if (EU.webkit)
		{
			EU._drwatch = setInterval(function()
			{
				var rs = document.readyState;

				if ("loaded" == rs || "complete" == rs)
				{
					clearInterval(EU._drwatch);
					EU._drwatch = null;
					EU._ready();
				}
			}, EU.POLL_INTERVAL);
		}
		else
		{
			EU._simpleAdd(document, "DOMContentLoaded", EU._ready);
		}
		EU._simpleAdd(window, "load", EU._load);
		EU._simpleAdd(window, "unload", EU._unload);
		EU._tryPreloadAttach();
	})();
}
YAHOO.util.EventProvider = function()
{
};

YAHOO.util.EventProvider.prototype =
{
	__yui_events: null,
	__yui_subscribers: null,
	subscribe: function(p_type, p_fn, p_obj, p_override)
	{
		this.__yui_events = this.__yui_events || {};
		var ce = this.__yui_events[p_type];

		if (ce)
		{
			ce.subscribe(p_fn, p_obj, p_override);
		}
		else
		{
			this.__yui_subscribers = this.__yui_subscribers || {};
			var subs = this.__yui_subscribers;

			if (!subs[p_type])
			{
				subs[p_type] = [];
			}
			subs[p_type].push(
			{
				fn: p_fn,
				obj: p_obj,
				override: p_override
			});
		}
	},
	unsubscribe: function(p_type, p_fn, p_obj)
	{
		this.__yui_events = this.__yui_events || {};
		var evts = this.__yui_events;

		if (p_type)
		{
			var ce = evts[p_type];

			if (ce)
			{
				return ce.unsubscribe(p_fn, p_obj);
			}
		}
		else
		{
			for (var i in evts)
			{
				var ret = true;

				if (YAHOO.lang.hasOwnProperty(evts, i))
				{
					ret = ret && evts[i].unsubscribe(p_fn, p_obj);
				}
			}
			return ret;
		}
		return false;
	},
	unsubscribeAll: function(p_type)
	{
		return this.unsubscribe(p_type);
	},
	createEvent: function(p_type, p_config)
	{
		this.__yui_events = this.__yui_events || {};
		var opts = p_config || {};
		var events = this.__yui_events;

		if (events[p_type])
		{
		}
		else
		{
			var scope = opts.scope || this;
			var silent = (opts.silent);
			var ce = new YAHOO.util.CustomEvent(p_type, scope, silent, YAHOO.util.CustomEvent.FLAT);
			events[p_type] = ce;

			if (opts.onSubscribeCallback)
			{
				ce.subscribeEvent.subscribe(opts.onSubscribeCallback);
			}
			this.__yui_subscribers = this.__yui_subscribers || {};
			var qs = this.__yui_subscribers[p_type];

			if (qs)
			{
				for (var i = 0; i < qs.length; ++i)
				{
					ce.subscribe(qs[i].fn, qs[i].obj, qs[i].override);
				}
			}
		}
		return events[p_type];
	},
	fireEvent: function(p_type, arg1, arg2, etc)
	{
		this.__yui_events = this.__yui_events || {};
		var ce = this.__yui_events[p_type];

		if (!ce)
		{
			return null;
		}
		var args = [];

		for (var i = 1; i < arguments.length; ++i)
		{
			args.push(arguments[i]);
		}
		return ce.fire.apply(ce, args);
	},
	hasEvent: function(type)
	{
		if (this.__yui_events)
		{
			if (this.__yui_events[type])
			{
				return true;
			}
		}
		return false;
	}
};
YAHOO.util.KeyListener = function(attachTo, keyData, handler, event)
{
	if (!attachTo)
	{
	}
	else if (!keyData)
	{
	}
	else if (!handler)
	{
	}

	if (!event)
	{
		event = YAHOO.util.KeyListener.KEYDOWN;
	}
	var keyEvent = new YAHOO.util.CustomEvent("keyPressed");
	this.enabledEvent = new YAHOO.util.CustomEvent("enabled");
	this.disabledEvent = new YAHOO.util.CustomEvent("disabled");

	if (typeof attachTo == 'string')
	{
		attachTo = document.getElementById(attachTo);
	}

	if (typeof handler == 'function')
	{
		keyEvent.subscribe(handler);
	}
	else
	{
		keyEvent.subscribe(handler.fn, handler.scope, handler.correctScope);
	}

	function handleKeyPress(e, obj)
{
	if (!keyData.shift)
	{
		keyData.shift = false;
	}

	if (!keyData.alt)
	{
		keyData.alt = false;
	}

	if (!keyData.ctrl)
	{
		keyData.ctrl = false;
	}

	if (e.shiftKey == keyData.shift && e.altKey == keyData.alt && e.ctrlKey == keyData.ctrl)
	{
		var dataItem;
		var keyPressed;

		if (keyData.keys instanceof Array)
		{
			for (var i = 0; i < keyData.keys.length; i++)
			{
				dataItem = keyData.keys[i];

				if (dataItem == e.charCode)
				{
					keyEvent.fire(e.charCode, e);
					break;
				}
				else if (dataItem == e.keyCode)
				{
					keyEvent.fire(e.keyCode, e);
					break;
				}
			}
		}
		else
		{
			dataItem = keyData.keys;

			if (dataItem == e.charCode)
			{
				keyEvent.fire(e.charCode, e);
			}
			else if (dataItem == e.keyCode)
			{
				keyEvent.fire(e.keyCode, e);
			}
		}
	}
}
	this.enable = function()
	{
		if (!this.enabled)
		{
			YAHOO.util.Event.addListener(attachTo, event, handleKeyPress);
			this.enabledEvent.fire(keyData);
		}
		this.enabled = true;
	};
	this.disable = function()
	{
		if (this.enabled)
		{
			YAHOO.util.Event.removeListener(attachTo, event, handleKeyPress);
			this.disabledEvent.fire(keyData);
		}
		this.enabled = false;
	};
	this.toString = function()
	{
		return "KeyListener [" + keyData.keys + "] " + attachTo.tagName + (attachTo.id ? "[" + attachTo.id + "]" : "");
	};
};
YAHOO.util.KeyListener.KEYDOWN = "keydown";
YAHOO.util.KeyListener.KEYUP = "keyup";
YAHOO.register("event", YAHOO.util.Event,
{
	version: "2.3.0",
	build: "442"
});

(function()
{
	var Y = YAHOO.util, getStyle, setStyle, id_counter = 0, propertyCache = {}, reClassNameCache = {};
	var isOpera = YAHOO.env.ua.opera, isSafari = YAHOO.env.ua.webkit, isGecko = YAHOO.env.ua.gecko,
		isIE = YAHOO.env.ua.ie;
	var patterns =
	{
		HYPHEN: /(-[a-z])/i,
		ROOT_TAG: /^body|html$/i
	};

	var toCamel = function(property)
	{
		if (!patterns.HYPHEN.test(property))
		{
			return property;
		}

		if (propertyCache[property])
		{
			return propertyCache[property];
		}
		var converted = property;

		while (patterns.HYPHEN.exec(converted))
		{
			converted = converted.replace(RegExp.$1, RegExp.$1.substr(1).toUpperCase());
		}
		propertyCache[property] = converted;
		return converted;
	};
	var getClassRegEx = function(className)
	{
		var re = reClassNameCache[className];

		if (!re)
		{
			re = new RegExp('(?:^|\\s+)' + className + '(?:\\s+|$)');
			reClassNameCache[className] = re;
		}
		return re;
	};

	if (document.defaultView && document.defaultView.getComputedStyle)
	{
		getStyle = function(el, property)
		{
			var value = null;

			if (property == 'float')
			{
				property = 'cssFloat';
			}
			var computed = document.defaultView.getComputedStyle(el, '');

			if (computed)
			{
				value = computed[toCamel(property)];
			}
			return el.style[property] || value;
		};
	}
	else if (document.documentElement.currentStyle && isIE)
	{
		getStyle = function(el, property)
		{
			switch (toCamel(property))

			{
				case 'opacity':
					var val = 100;

					try
					{
						val = el.filters['DXImageTransform.Microsoft.Alpha'].opacity;
					}
					catch (e)
					{
						try
						{
							val = el.filters('alpha').opacity;
						}
						catch (e)
						{
						}
					}
					return val / 100;

				case 'float':
					property = 'styleFloat';

				default:
					var value = el.currentStyle ? el.currentStyle[property] : null;
					return (el.style[property] || value);
			}
		};
	}
	else
	{
		getStyle = function(el, property)
		{
			return el.style[property];
		};
	}

	if (isIE)
	{
		setStyle = function(el, property, val)
		{
			switch (property)
			{
				case 'opacity':
					if (YAHOO.lang.isString(el.style.filter))
					{
						el.style.filter = 'alpha(opacity=' + val * 100 + ')';

						if (!el.currentStyle || !el.currentStyle.hasLayout)
						{
							el.style.zoom = 1;
						}
					}
					break;

				case 'float':
					property = 'styleFloat';

				default:
					el.style[property] = val;
			}
		};
	}
	else
	{
		setStyle = function(el, property, val)
		{
			if (property == 'float')
			{
				property = 'cssFloat';
			}
			el.style[property] = val;
		};
	}
	var testElement = function(node, method)
	{
		return node && node.nodeType == 1 && (!method || method(node));
	};
	YAHOO.util.Dom =
	{
		get: function(el)
		{
			if (!el || el.tagName || el.item)
			{
				return el;
			}

			if (YAHOO.lang.isString(el))
			{
				return document.getElementById(el);
			}

			if (el.splice)
			{
				var c = [];

				for (var i = 0, len = el.length; i < len; ++i)
				{
					c[c.length] = Y.Dom.get(el[i]);
				}
				return c;
			}
			return el;
		},
		getStyle: function(el, property)
		{
			property = toCamel(property);
			var f = function(element)
			{
				return getStyle(element, property);
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		setStyle: function(el, property, val)
		{
			property = toCamel(property);
			var f = function(element)
			{
				setStyle(element, property, val);
			};
			Y.Dom.batch(el, f, Y.Dom, true);
		},
		getXY: function(el)
		{
			var f = function(el)
			{
				if ((el.parentNode === null || el.offsetParent === null || this.getStyle(el, 'display') == 'none')
					&& el != document.body)
				{
					return false;
				}
				var parentNode = null;
				var pos = [];
				var box;
				var doc = el.ownerDocument;

				if (el.getBoundingClientRect)
				{
					box = el.getBoundingClientRect();
					return [box.left + Y.Dom.getDocumentScrollLeft(el.ownerDocument),
						box.top + Y.Dom.getDocumentScrollTop(el.ownerDocument)];
				}
				else
				{
					pos = [el.offsetLeft, el.offsetTop];
					parentNode = el.offsetParent;
					var hasAbs = this.getStyle(el, 'position') == 'absolute';

					if (parentNode != el)
					{
						while (parentNode)
						{
							pos[0] += parentNode.offsetLeft;
							pos[1] += parentNode.offsetTop;

							if (isSafari && !hasAbs && this.getStyle(parentNode, 'position') == 'absolute')
							{
								hasAbs = true;
							}
							parentNode = parentNode.offsetParent;
						}
					}

					if (isSafari && hasAbs)
					{
						pos[0] -= el.ownerDocument.body.offsetLeft;
						pos[1] -= el.ownerDocument.body.offsetTop;
					}
				}
				parentNode = el.parentNode;

				while (parentNode.tagName && !patterns.ROOT_TAG.test(parentNode.tagName))
				{
					if (Y.Dom.getStyle(parentNode, 'display').search(/^inline|table-row.*$/i))
					{
						pos[0] -= parentNode.scrollLeft;
						pos[1] -= parentNode.scrollTop;
					}
					parentNode = parentNode.parentNode;
				}
				return pos;
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		getX: function(el)
		{
			var f = function(el)
			{
				return Y.Dom.getXY(el)[0];
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		getY: function(el)
		{
			var f = function(el)
			{
				return Y.Dom.getXY(el)[1];
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		setXY: function(el, pos, noRetry)
		{
			var f = function(el)
			{
				var style_pos = this.getStyle(el, 'position');

				if (style_pos == 'static')
				{
					this.setStyle(el, 'position', 'relative');
					style_pos = 'relative';
				}
				var pageXY = this.getXY(el);

				if (pageXY === false)
				{
					return false;
				}
				var delta = [parseInt(this.getStyle(el, 'left'), 10), parseInt(this.getStyle(el, 'top'), 10)];

				if (isNaN(delta[0]))
				{
					delta[0] = (style_pos == 'relative') ? 0 : el.offsetLeft;
				}

				if (isNaN(delta[1]))
				{
					delta[1] = (style_pos == 'relative') ? 0 : el.offsetTop;
				}

				if (pos[0] !== null)
				{
					el.style.left = pos[0] - pageXY[0] + delta[0] + 'px';
				}

				if (pos[1] !== null)
				{
					el.style.top = pos[1] - pageXY[1] + delta[1] + 'px';
				}

				if (!noRetry)
				{
					var newXY = this.getXY(el);

					if ((pos[0] !== null && newXY[0] != pos[0]) || (pos[1] !== null && newXY[1] != pos[1]))
					{
						this.setXY(el, pos, true);
					}
				}
			};
			Y.Dom.batch(el, f, Y.Dom, true);
		},
		setX: function(el, x)
		{
			Y.Dom.setXY(el, [x, null]);
		},
		setY: function(el, y)
		{
			Y.Dom.setXY(el, [null, y]);
		},
		getRegion: function(el)
		{
			var f = function(el)
			{
				if ((el.parentNode === null || el.offsetParent === null || this.getStyle(el, 'display') == 'none')
					&& el != document.body)
				{
					return false;
				}
				var region = Y.Region.getRegion(el);
				return region;
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		getClientWidth: function()
		{
			return Y.Dom.getViewportWidth();
		},
		getClientHeight: function()
		{
			return Y.Dom.getViewportHeight();
		},
		getElementsByClassName: function(className, tag, root, apply)
		{
			tag = tag || '*';
			root = (root) ? Y.Dom.get(root) : null || document;

			if (!root)
			{
				return [];
			}
			var nodes = [], elements = root.getElementsByTagName(tag), re = getClassRegEx(className);

			for (var i = 0, len = elements.length; i < len; ++i)
			{
				if (re.test(elements[i].className))
				{
					nodes[nodes.length] = elements[i];

					if (apply)
					{
						apply.call(elements[i], elements[i]);
					}
				}
			}
			return nodes;
		},
		hasClass: function(el, className)
		{
			var re = getClassRegEx(className);
			var f = function(el)
			{
				return re.test(el.className);
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		addClass: function(el, className)
		{
			var f = function(el)
			{
				if (this.hasClass(el, className))
				{
					return false;
				}
				el.className = YAHOO.lang.trim(
				[
					el.className,
					className
				].join(' '));

				return true;
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		removeClass: function(el, className)
		{
			var re = getClassRegEx(className);
			var f = function(el)
			{
				if (!this.hasClass(el, className))
				{
					return false;
				}
				var c = el.className;
				el.className = c.replace(re, ' ');

				if (this.hasClass(el, className))
				{
					this.removeClass(el, className);
				}
				el.className = YAHOO.lang.trim(el.className);
				return true;
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		replaceClass: function(el, oldClassName, newClassName)
		{
			if (!newClassName || oldClassName === newClassName)
			{
				return false;
			}
			var re = getClassRegEx(oldClassName);
			var f = function(el)
			{
				if (!this.hasClass(el, oldClassName))
				{
					this.addClass(el, newClassName);
					return true;
				}
				el.className = el.className.replace(re, ' ' + newClassName + ' ');

				if (this.hasClass(el, oldClassName))
				{
					this.replaceClass(el, oldClassName, newClassName);
				}
				el.className = YAHOO.lang.trim(el.className);
				return true;
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		generateId: function(el, prefix)
		{
			prefix = prefix || 'yui-gen';
			var f = function(el)
			{
				if (el && el.id)
				{
					return el.id;
				}
				var id = prefix + id_counter++;

				if (el)
				{
					el.id = id;
				}
				return id;
			};
			return Y.Dom.batch(el, f, Y.Dom, true) || f.apply(Y.Dom, arguments);
		},
		isAncestor: function(haystack, needle)
		{
			haystack = Y.Dom.get(haystack);

			if (!haystack || !needle)
			{
				return false;
			}
			var f = function(node)
			{
				if (haystack.contains && node.nodeType && !isSafari)
				{
					return haystack.contains(node);
				}
				else if (haystack.compareDocumentPosition && node.nodeType)
				{
					return ! !(haystack.compareDocumentPosition(node) & 16);
				}
				else if (node.nodeType)
				{
					return ! !this.getAncestorBy(node, function(el)
					{
						return el == haystack;
					});
				}
				return false;
			};
			return Y.Dom.batch(needle, f, Y.Dom, true);
		},
		inDocument: function(el)
		{
			var f = function(el)
			{
				if (isSafari)
				{
					while (el = el.parentNode)
					{
						if (el == document.documentElement)
						{
							return true;
						}
					}
					return false;
				}
				return this.isAncestor(document.documentElement, el);
			};
			return Y.Dom.batch(el, f, Y.Dom, true);
		},
		getElementsBy: function(method, tag, root, apply)
		{
			tag = tag || '*';
			root = (root) ? Y.Dom.get(root) : null || document;

			if (!root)
			{
				return [];
			}
			var nodes = [], elements = root.getElementsByTagName(tag);

			for (var i = 0, len = elements.length; i < len; ++i)
			{
				if (method(elements[i]))
				{
					nodes[nodes.length] = elements[i];

					if (apply)
					{
						apply(elements[i]);
					}
				}
			}
			return nodes;
		},
		batch: function(el, method, o, override)
		{
			el = (el && el.tagName) ? el : Y.Dom.get(el);

			if (!el || !method)
			{
				return false;
			}
			var scope = (override) ? o : window;

			if (el.tagName || (!el.item && !el.slice))
			{
				return method.call(scope, el, o);
			}
			var collection = [];

			for (var i = 0, len = el.length; i < len; ++i)
			{
				collection[collection.length] = method.call(scope, el[i], o);
			}
			return collection;
		},
		getDocumentHeight: function()
		{
			var scrollHeight = (document.compatMode != 'CSS1Compat')
				? document.body.scrollHeight : document.documentElement.scrollHeight;
			var h = Math.max(scrollHeight, Y.Dom.getViewportHeight());
			return h;
		},
		getDocumentWidth: function()
		{
			var scrollWidth = (document.compatMode != 'CSS1Compat')
				? document.body.scrollWidth : document.documentElement.scrollWidth;
			var w = Math.max(scrollWidth, Y.Dom.getViewportWidth());
			return w;
		},
		getViewportHeight: function()
		{
			var height = self.innerHeight;
			var mode = document.compatMode;

			if ((mode || isIE) && !isOpera)
			{
				height = (mode == 'CSS1Compat') ? document.documentElement.clientHeight : document.body.clientHeight;
			}
			return height;
		},
		getViewportWidth: function()
		{
			var width = self.innerWidth;
			var mode = document.compatMode;

			if (mode || isIE)
			{
				width = (mode == 'CSS1Compat') ? document.documentElement.clientWidth : document.body.clientWidth;
			}
			return width;
		},
		getAncestorBy: function(node, method)
		{
			while (node = node.parentNode)
			{
				if (testElement(node, method))
				{
					return node;
				}
			}
			return null;
		},
		getAncestorByClassName: function(node, className)
		{
			node = Y.Dom.get(node);

			if (!node)
			{
				return null;
			}
			var method = function(el)
			{
				return Y.Dom.hasClass(el, className);
			};
			return Y.Dom.getAncestorBy(node, method);
		},
		getAncestorByTagName: function(node, tagName)
		{
			node = Y.Dom.get(node);

			if (!node)
			{
				return null;
			}
			var method = function(el)
			{
				return el.tagName && el.tagName.toUpperCase() == tagName.toUpperCase();
			};
			return Y.Dom.getAncestorBy(node, method);
		},
		getPreviousSiblingBy: function(node, method)
		{
			while (node)
			{
				node = node.previousSibling;

				if (testElement(node, method))
				{
					return node;
				}
			}
			return null;
		},
		getPreviousSibling: function(node)
		{
			node = Y.Dom.get(node);

			if (!node)
			{
				return null;
			}
			return Y.Dom.getPreviousSiblingBy(node);
		},
		getNextSiblingBy: function(node, method)
		{
			while (node)
			{
				node = node.nextSibling;

				if (testElement(node, method))
				{
					return node;
				}
			}
			return null;
		},
		getNextSibling: function(node)
		{
			node = Y.Dom.get(node);

			if (!node)
			{
				return null;
			}
			return Y.Dom.getNextSiblingBy(node);
		},
		getFirstChildBy: function(node, method)
		{
			var child = (testElement(node.firstChild, method)) ? node.firstChild : null;
			return child || Y.Dom.getNextSiblingBy(node.firstChild, method);
		},
		getFirstChild: function(node, method)
		{
			node = Y.Dom.get(node);

			if (!node)
			{
				return null;
			}
			return Y.Dom.getFirstChildBy(node);
		},
		getLastChildBy: function(node, method)
		{
			if (!node)
			{
				return null;
			}
			var child = (testElement(node.lastChild, method)) ? node.lastChild : null;
			return child || Y.Dom.getPreviousSiblingBy(node.lastChild, method);
		},
		getLastChild: function(node)
		{
			node = Y.Dom.get(node);
			return Y.Dom.getLastChildBy(node);
		},
		getChildrenBy: function(node, method)
		{
			var child = Y.Dom.getFirstChildBy(node, method);
			var children = child ? [child] : [];
			Y.Dom.getNextSiblingBy(child, function(node)
			{
				if (!method || method(node))
				{
					children[children.length] = node;
				}
				return false;
			});
			return children;
		},
		getChildren: function(node)
		{
			node = Y.Dom.get(node);

			if (!node)
			{
			}

			return Y.Dom.getChildrenBy(node);
		},
		getDocumentScrollLeft: function(doc)
		{
			doc = doc || document;
			return Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft);
		},
		getDocumentScrollTop: function(doc)
		{
			doc = doc || document;
			return Math.max(doc.documentElement.scrollTop, doc.body.scrollTop);
		},
		insertBefore: function(newNode, referenceNode)
		{
			newNode = Y.Dom.get(newNode);
			referenceNode = Y.Dom.get(referenceNode);

			if (!newNode || !referenceNode || !referenceNode.parentNode)
			{
				return null;
			}
			return referenceNode.parentNode.insertBefore(newNode, referenceNode);
		},
		insertAfter: function(newNode, referenceNode)
		{
			newNode = Y.Dom.get(newNode);
			referenceNode = Y.Dom.get(referenceNode);

			if (!newNode || !referenceNode || !referenceNode.parentNode)
			{
				return null;
			}

			if (referenceNode.nextSibling)
			{
				return referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
			}
			else
			{
				return referenceNode.parentNode.appendChild(newNode);
			}
		}
	};
})();
YAHOO.util.Region = function(t, r, b, l)
{
	this.top = t;
	this[1] = t;
	this.right = r;
	this.bottom = b;
	this.left = l;
	this[0] = l;
};
YAHOO.util.Region.prototype.contains = function(region)
{
	return (region.left >= this.left && region.right <= this.right && region.top >= this.top
		&& region.bottom <= this.bottom);
};
YAHOO.util.Region.prototype.getArea = function()
{
	return ((this.bottom - this.top) * (this.right - this.left));
};
YAHOO.util.Region.prototype.intersect = function(region)
{
	var t = Math.max(this.top, region.top);
	var r = Math.min(this.right, region.right);
	var b = Math.min(this.bottom, region.bottom);
	var l = Math.max(this.left, region.left);

	if (b >= t && r >= l)
	{
		return new YAHOO.util.Region(t, r, b, l);
	}
	else
	{
		return null;
	}
};
YAHOO.util.Region.prototype.union = function(region)
{
	var t = Math.min(this.top, region.top);
	var r = Math.max(this.right, region.right);
	var b = Math.max(this.bottom, region.bottom);
	var l = Math.min(this.left, region.left);
	return new YAHOO.util.Region(t, r, b, l);
};
YAHOO.util.Region.prototype.toString = function()
{
	return ("Region {" + "top: " + this.top + ", right: " + this.right + ", bottom: " + this.bottom + ", left: "
		+ this.left + "}");
};
YAHOO.util.Region.getRegion = function(el)
{
	var p = YAHOO.util.Dom.getXY(el);
	var t = p[1];
	var r = p[0] + el.offsetWidth;
	var b = p[1] + el.offsetHeight;
	var l = p[0];
	return new YAHOO.util.Region(t, r, b, l);
};
YAHOO.util.Point = function(x, y)
{
	if (YAHOO.lang.isArray(x))
	{
		y = x[1];
		x = x[0];
	}
	this.x = this.right = this.left = this[0] = x;
	this.y = this.top = this.bottom = this[1] = y;
};
YAHOO.util.Point.prototype = new YAHOO.util.Region();
YAHOO.register("dom", YAHOO.util.Dom,
{
	version: "2.3.0",
	build: "442"
});

if (!Array.prototype.indexOf)
{
	Array.prototype.indexOf = function(obj, fromIndex)
	{
		if (fromIndex == null)
		{
			fromIndex = 0;
		}
		else if (fromIndex < 0)
		{
			fromIndex = Math.max(0, this.length + fromIndex);
		}

		for (var i = fromIndex; i < this.length; i++)
		{
			if (this[i] === obj)
				return i;
		}
		return -1;
	};
}

if (!Array.prototype.lastIndexOf)
{
	Array.prototype.lastIndexOf = function(obj, fromIndex)
	{
		if (fromIndex == null)
		{
			fromIndex = this.length - 1;
		}
		else if (fromIndex < 0)
		{
			fromIndex = Math.max(0, this.length + fromIndex);
		}

		for (var i = fromIndex; i >= 0; i--)
		{
			if (this[i] === obj)
				return i;
		}
		return -1;
	};
}

if (!Array.prototype.forEach)
{
	Array.prototype.forEach = function(f, obj)
	{
		var l = this.length;

		for (var i = 0; i < l; i++)
		{
			f.call(obj, this[i], i, this);
		}
	};
}

if (!Array.prototype.filter)
{
	Array.prototype.filter = function(f, obj)
	{
		var l = this.length;
		var res = [];

		for (var i = 0; i < l; i++)
		{
			if (f.call(obj, this[i], i, this))
			{
				res.push(this[i]);
			}
		}
		return res;
	};
}

if (!Array.prototype.map)
{
	Array.prototype.map = function(f, obj)
	{
		var l = this.length;
		var res = [];

		for (var i = 0; i < l; i++)
		{
			res.push(f.call(obj, this[i], i, this));
		}
		return res;
	};
}

if (!Array.prototype.some)
{
	Array.prototype.some = function(f, obj)
	{
		var l = this.length;

		for (var i = 0; i < l; i++)
		{
			if (f.call(obj, this[i], i, this))
			{
				return true;
			}
		}
		return false;
	};
}

if (!Array.prototype.every)
{
	Array.prototype.every = function(f, obj)
	{
		var l = this.length;

		for (var i = 0; i < l; i++)
		{
			if (!f.call(obj, this[i], i, this))
			{
				return false;
			}
		}
		return true;
	};
}
Array.prototype.contains = function(obj)
{
	return this.indexOf(obj) != -1;
};
Array.prototype.copy = function(obj)
{
	return this.concat();
};
Array.prototype.insertAt = function(obj, i)
{
	this.splice(i, 0, obj);
};
Array.prototype.insertBefore = function(obj, obj2)
{
	var i = this.indexOf(obj2);

	if (i == -1)
		this.push(obj);
	else
		this.splice(i, 0, obj);
};
Array.prototype.removeAt = function(i)
{
	this.splice(i, 1);
};
Array.prototype.remove = function(obj)
{
	var i = this.indexOf(obj);

	if (i != -1)
		this.splice(i, 1);
};

if (!String.prototype.toQueryParams)
{
	String.prototype.toQueryParams = function()
	{
		var hash = {};
		var params = this.trim().split('&');

		for (var j = 0; j < params.length; j++)
		{
			var pair = params[j].split('=');
			var name = decodeURIComponent(pair[0]);
			var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;

			if (hash[name] !== undefined)
			{
				if (hash[name].constructor != Array)
					hash[name] = [hash[name]];

				if (value)
					hash[name].push(value);
			}
			else
			{
				hash[name] = value;
			}
		}
		return hash;
	}
}

if (!String.prototype.trim)
{
	String.prototype.trim = function()
	{
		var re = /^\s+|\s+$/g;
		return function()
		{
			return this.replace(re, "");
		};
	}();
}

if (!String.prototype.replaceAll)
{
	String.prototype.replaceAll = function(from, to)
	{
		var re = eval("/" + from + "/g");
		return (this.replace(re, to));
	};
}
$D = YAHOO.util.Dom;
$E = YAHOO.util.Event;
$ = $D.get;
TB = {};
TB.namespace = function()
{
	var a = arguments, o = null, i, j, d;

	for (i = 0; i < a.length; i = i + 1)
	{
		d = a[i].split(".");
		o = TB;

		for (j = (d[0] == "TB") ? 1 : 0; j < d.length; j = j + 1)
		{
			o[d[j]] = o[d[j]] || {};
			o = o[d[j]];
		}
	}
	return o;
};
TB.namespace('env');
TB.env =
{
	hostname: 'view2offer.com.sg',
	scriptName: 'base.js',
	debug: false,
	lang: (navigator.userLanguage ? navigator.userLanguage.toLowerCase() : navigator.language.toLowerCase())
};

TB.namespace('locale');
TB.locale =
{
	Messages: {},
	getMessage: function(key)
	{
		return TB.locale.Messages[key] || key;
	},
	setMessage: function(key, value)
	{
		TB.locale.Messages[key] = value;
	}
}
$M = TB.locale.getMessage;
TB.trace = function(msg)
{
	if (!TB.env.debug)
		return;

	if (window.console)
	{
		window.console.debug(msg);
	}
	else
	{
		alert(msg);
	}
}
TB.init = function()
{
	this.namespace('widget', 'dom', 'bom', 'util', 'form', 'anim');
	var scripts = document.getElementsByTagName("script");
	var idx, urlPrefix;

	for (var i = 0; i < scripts.length; i++)
	{
		if ((idx = scripts[i].src.indexOf(TB.env.scriptName)) > 0)
		{
			urlPrefix = scripts[i].src.substring(0, idx);
			var matchs = scripts[i].src.match(/\?(.*)$/);

			if (matchs)
			{
				var params = matchs[1].toQueryParams();

				for (n in params)
				{
					if (n == 't')
						n = 'timestamp';
					TB.env[n] = params[n];
				}
			}
		}
	}
}
TB.locale.Messages =
{
	loading: 'Loading...',
	pleaseWait: 'Please waiting...',
	ajaxError: 'System Error',
	prevPageText: 'Next Page',
	nextPageText: 'Previous Page',
	year: 'year',
	month: 'month',
	day: 'day',
	hour: 'hour',
	minute: 'minute',
	second: 'second',
	timeoutText: 'Timeout'
}

TB.init();
TB.common =
{
	trim: function(str)
	{
		return str.replace(/(^\s*)|(\s*$)/g, '');
	},
	escapeHTML: function(str)
	{
		var div = document.createElement('div');
		var text = document.createTextNode(str);
		div.appendChild(text);
		return div.innerHTML;
	},
	unescapeHTML: function(str)
	{
		var div = document.createElement('div');
		div.innerHTML = str.replace(/<\/?[^>]+>/gi, '');
		return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
	},
	stripTags: function(str)
	{
		return str.replace(/<\/?[^>]+>/gi, '');
	},
	toArray: function(list, start)
	{
		var array = [];

		for (var i = start || 0; i < list.length; i++)
		{
			array[array.length] = list[i];
		}
		return array;
	},
	applyIf: function(obj, config)
	{
		if (obj && config && typeof config == 'object')
		{
			for (var p in config)
			{
				if (!YAHOO.lang.hasOwnProperty(obj, p))
					obj[p] = config[p];
			}
		}
		return obj;
	},
	apply: function(obj, config)
	{
		if (obj && config && typeof config == 'object')
		{
			for (var p in config)
				obj[p] = config[p];
		}
		return obj;
	},
	_messagePattern: /\{([\w-]+)?\}/g,
	formatMessage: function(msg, values, filter)
	{
		return msg.replace(this._messagePattern, function(match, key)
		{
			return filter ? filter(values[key], key) : values[key];
		});
	}
};
TB.applyIf = TB.common.applyIf;
TB.apply = TB.common.apply;
(function()
{
	var ua = navigator.userAgent.toLowerCase();
	var _isOpera = ua.indexOf('opera') != -1, _isSafari = ua.indexOf('safari') != -1,
		_isGecko = !_isOpera && !_isSafari && ua.indexOf('gecko') > -1, _isIE = !_isOpera && ua.indexOf('msie') != -1,
		_isIE6 = !_isOpera && ua.indexOf('msie 6') != -1, _isIE7 = !_isOpera && ua.indexOf('msie 7') != -1;
	TB.bom =
	{
		isOpera: _isOpera,
		isSafari: _isSafari,
		isGecko: _isGecko,
		isIE: _isIE,
		isIE6: _isIE6,
		isIE7: _isIE7,
		getCookie: function(name)
		{
			var value = document.cookie.match('(?:^|;)\\s*' + name + '=([^;]*)');
			return value ? unescape(value[1]) : '';
		},
		setCookie: function(name, value, expire, domain, path)
		{

			value = escape(value);
			value += (domain) ? '; domain=' + domain : '';
			value += (path) ? "; path=" + path : '';

			if (expire)
			{
				var date = new Date();
				date.setTime(date.getTime() + (expire * 86400000));
				value += "; expires=" + date.toGMTString();
			}
			document.cookie = name + "=" + value;
		},
		removeCookie: function(name)
		{
			setCookie(name, '', -1);
		},
		pickDocumentDomain: function()
		{
			var da = location.hostname.split('.'), len = da.length;
			var deep = arguments[0] || (len < 3 ? 0 : 1);

			if (deep >= len || len - deep < 2)
				deep = len - 2;
			return da.slice(deep).join('.');
		}
	}
})();
TB.dom =
{
	insertAfter: function(node, refNode)
	{
		var node = $(node), refNode = $(refNode);

		if (refNode.nextSibling)
		{
			return refNode.parentNode.insertBefore(node, refNode.nextSibling);
		}
		else
		{
			return refNode.parentNode.appendChild(node);
		}
	},
	getAncestorByTagName: function(el, tag)
	{
		el = $(el);
		tag = tag.toUpperCase();

		while (el.parentNode)
		{
			if (el.tagName.toUpperCase() == tag)
				return el;

			if (el.tagName.toUpperCase() == "BODY")
				return null;
			el = el.parentNode;
		}
		return null;
	},
	getAncestorByClassName: function(el, cls)
	{
		el = $(el);

		while (el.parentNode)
		{
			if ($D.hasClass(el, cls))
				return el;

			if (el.tagName.toUpperCase == "BODY")
				return null;

			el = el.parentNode;
		}
		return null;
	},
	getNextSibling: function(el)
	{
		var sibling = $(el).nextSibling;

		while (sibling.nodeType != 1)
		{
			sibling = sibling.nextSibling;
		}
		return sibling;
	},
	getPreviousSibling: function(el)
	{
		var sibling = $(el).previousSibling;

		while (sibling.nodeType != 1)
		{
			sibling = sibling.previousSibling;
		}
		return sibling;
	},
	getFieldLabelHtml: function(el, parent)
	{
		var labels = (parent || el.parentNode).getElementsByTagName('label');

		for (var i = 0; i < labels.length; i++)
		{
			var forAttr = labels[i].htmlFor || labels[i].getAttribute('for')

			if (forAttr == input.id)
				return labels[i].innerHTML;
		}
	},
	getIframeDocument: function(el)
	{
		var iframe = $(el);
		return iframe.contentWindow ? iframe.contentWindow.document : iframe.contentDocument;
	},
	setFormAction: function(form, url)
	{
		form = $('form');
		var actionInput = form.elements['action'];
		var postSet;

		if (actionInput)
		{
			var ai = form.removeChild(actionInput);
			postSet = function()
			{
				form.appendChild(ai);
			}
		}
		form.action = url;

		if (postSet)
			postSet();
		return true;
	}
}
var AE = {};
AE.widget = TB.widget;
AE.browse = TB.bom;
AE.bom = TB.bom;
AE.common = TB.common;
AE.cpAttribute = function(obj, config)
{
	if (obj && config && typeof config == 'object')
	{
		for (var p in config)
		{
			if (!YAHOO.lang.hasOwnProperty(obj, p))
				obj[p] = config[p];
		}
	}

	return obj;
}

if (!IL)
{
	var IL =
	{
		ok: "Ok",
		cancel: "Cancel"
	};
}

var YL = YAHOO.lang;
var YUD = YAHOO.util.Dom;
var YUE = YAHOO.util.Event;
YUD.setCookie = TB.bom.setCookie;
YUD.getCookie = TB.bom.getCookie;
YUD.deleteCookie = TB.bom.removeCookie;

function vd(p)
{
}
String.prototype.ltrim = function()
{
	return this.replace(/(^\s*)/g, "");
}
String.prototype.rtrim = function()
{
	return this.replace(/(\s*$)/g, "");
}
String.prototype.isEmpty = function()
{
	if (this == "" || this == '')
	{
		return true;
	}
	else
	{
		return false;
	}
}
YL.isEnglish = function(sValue)
{
	var myReg = /[^\x00-\x80]/g;

	if (myReg.test(sValue))
	{
		return false;
	}
	else
	{
		return true;
	}
}
YL.isAscii = function(sValue)
{
	var myReg = /[^\x00-\xFF]/g;

	if (myReg.test(sValue))
	{
		return false
	}
	else
	{
		return true;
	}
}
var get = YUD.get;

function controlListShow(e, sClassName, sTagName, sParentNodeId, sVisible)
{
	var items = YUD.getElementsByClassName(sClassName, sTagName, get(sParentNodeId));

	if (sVisible || sVisible == '' || sVisible == "")
	{
		YUD.setStyle(items, "display", sVisible);
	}
	else
	{
		if (items[0].style.display == "none")
		{
			YUD.setStyle(items, "display", "");
		}
		else
		{
			YUD.setStyle(items, "display", "none");
		}
	}
}

function addMoreAttributeContent(sContent, sButtonId, sContainerTagName)
{
	var oActionButton = get(sButtonId);
	var span = document.createElement(sContainerTagName);
	var separator = document.createElement('div');
	separator.style.Clear = "both";
	span.innerHTML = sContent;
	oActionButton.parentNode.insertBefore(separator, oActionButton);
	oActionButton.parentNode.insertBefore(span, oActionButton);
}

if (!AE.widget.clickShow)
{
	AE.widget.clickShow = function()
	{
		var oComponent = this;
		var defConfig =
		{
			targetId: "clickShowTargetId",
			contentId: "clickShowContentId",
			needMask: false,
			needXY: true,
			excursion:
			[
				0,
				0
			]
		};

		var config;
		var isInited = false;
		var dTarget, dContent, iframeMask;
		var canClose = true;
		oComponent.init = function(oConfig)
		{
			if (isInited)
				return false;

			config = TB.applyIf(oConfig || {}, defConfig);
			dTarget = get(config.targetId);
			dContent = get(config.contentId);
			YUE.on(dTarget, "click", oComponent.showDirectly);
			YUE.on(document.body, "click", oComponent.hiddenDirectly);
			YUE.on(dTarget, "mouseover", function()
			{
				canClose = false;
			});
			YUE.on(dContent, "mouseover", function()
			{
				canClose = false;
			});
			YUE.on(dTarget, "mouseout", function()
			{
				canClose = true;
			});
			YUE.on(dContent, "mouseout", function()
			{
				canClose = true;
			});

			if (config.needMask)
			{
				iframeMask = document.createElement("iframe");
				iframeMask.className = "maskIframe";
				iframeMask.style.display = "none";
				(dContent.style.zIndex <= 0)
					? iframeMask.style.zIndex = 1 : iframeMask.style.zIndex = dContent.style.zIndex - 1;
				iframeMask.style.top = "0px";
				iframeMask.style.left = "0px";
				iframeMask.frameBorder = 0;
				dContent.parentNode.appendChild(iframeMask);
			}
		}
		oComponent.showDirectly = function()
		{
			if (config.needXY)
			{
				var xy = YUD.getXY(dTarget);
				xy[0] += config.excursion[0];
				xy[1] += config.excursion[1];
				dContent.style.display = "";
				YUD.setXY(dContent, xy);
			}
			else
			{
				dContent.style.display = "";
			}
			YUD.setStyle(dContent, '0pacity', 1);

			if (config.needMask)
			{
				iframeMask.style.display = "";
				iframeMask.style.width = dContent.offsetWidth + "px";
				iframeMask.style.height = dContent.offsetHeight + "px";

				if (config.needXY)
				{
					YUD.setXY(iframeMask, xy);
				}
				iframeMask.style.visibility = "visible";
			}
		}
		oComponent.hiddenDirectly = function(ev, force)
		{
			if (canClose || force)
			{
				dContent.style.display = "none";

				if (config.needMask)
				{
					iframeMask.style.display = "none";
				}
			}
		}
	}
}

divCycle = function()
{
	var oComponent = this;
	var oDefConfig =
	{
		sTabClass: "productCycleTab",
		sItemClass: "productCycleItem",
		oParentNode: document.body,
		sSwitchEvent: "click",
		iDelayTime: 3000,
		iCycleTimes: 1,
		sCurrentClass: "current",
		sOrder: "asc"
	}

	var aTabs, aItems, oParent;
	var iDelayTime;
	var oTimer;
	var currentIndex = getid;
	var dataLength;
	var iCycleTimes = 0;
	oComponent.init = function(oConfig)
	{
		if (!oConfig && !YL.isObject(oConfig))
		{
			oConfig = {}
		}
		(YL.isString(oConfig.sTabClass)) ? oDefConfig.sTabClass = oConfig.sTabClass : null;
		(YL.isString(oConfig.sItemClass)) ? oDefConfig.sItemClass = oConfig.sItemClass : null;
		(YL.isObject(oConfig.oParentNode)) ? oDefConfig.oParentNode = oConfig.oParentNode : null;
		(YL.isString(oConfig.sSwitchEvent)) ? oDefConfig.sSwitchEvent = oConfig.sSwitchEvent : null;
		(YL.isNumber(oConfig.iDelayTime)) ? oDefConfig.iDelayTime = oConfig.iDelayTime : null;
		(YL.isNumber(oConfig.iCycleTimes)) ? oDefConfig.iCycleTimes = oConfig.iCycleTimes : null;
		(YL.isString(oConfig.sCurrentClass)) ? oDefConfig.sCurrentClass = oConfig.sCurrentClass : null;
		(YL.isString(oConfig.sOrder)) ? oDefConfig.sOrder = oConfig.sOrder : null;
		aTabs = YUD.getElementsByClassName(oDefConfig.sTabClass, '*', oDefConfig.oParentNode);
		aItems = YUD.getElementsByClassName(oDefConfig.sItemClass, '*', oDefConfig.oParentNode);
		oParent = oDefConfig.oParentNode;
		dataLength = Math.min(aTabs.length, aItems.length);

		if (oDefConfig.sOrder == "desc")
		{
			currentIndex = dataLength - 1;
		}
		YUE.on(aTabs, "mouseover", oComponent.stop);
		YUE.on(aTabs, "mouseout", oComponent.start);
		YUE.on(aItems, "mouseover", oComponent.stop);
		YUE.on(aItems, "mouseout", oComponent.start);

		for (i = 0; i < dataLength; i++)
		{
			YUE.on(aTabs[i], oDefConfig.sSwitchEvent, oComponent.show, i);
		}
		oComponent.start();
	}
	oComponent.start = function()
	{
		clearInterval(oTimer);
		oTimer = setInterval(switchItem, oDefConfig.iDelayTime);
	}
	oComponent.stop = function()
	{
		clearInterval(oTimer);
	}
	oComponent.show = function(e, iIndex)
	{
		if (!YL.isNumber(iIndex) || iIndex < 0 || iIndex >= dataLength)
		{
			return false;
		}
		currentIndex = iIndex;
		var f1 = function(element)
		{
			return YUD.removeClass(element, oDefConfig.sCurrentClass);
		}
		YUD.batch(aTabs, f1);
		YUD.addClass(aTabs[iIndex], oDefConfig.sCurrentClass);
		YUD.setStyle(aItems, "display", "none");
		YUD.setStyle(aItems[iIndex], "display", "");
	}
	var switchItem = function()
	{
		oComponent.show(null, currentIndex);

		if (iCycleTimes >= oDefConfig.iCycleTimes)
		{
			oComponent.stop();
			YUE.removeListener(aTabs, "mouseover", oComponent.stop);
			YUE.removeListener(aTabs, "mouseout", oComponent.start);
			YUE.removeListener(aItems, "mouseover", oComponent.stop);
			YUE.removeListener(aItems, "mouseout", oComponent.start);

			switch (oDefConfig.sOrder)
			{
				case ("asc"):
					{}

				case ("desc"):
					{
						break;
					}
			}
		}

		switch (oDefConfig.sOrder)
		{
			case ("asc"):
				{
					currentIndex++;

					if (currentIndex >= dataLength)
					{
						currentIndex = 1;
						iCycleTimes++;
					}
					break;
				}

			case ("desc"):
				{
					currentIndex--;

					if (currentIndex < 0)
					{
						currentIndex = dataLength - 1;
						iCycleTimes++;
					}
					break;
				}
		}
	}
}

// Media Tab Function (Duplicate Above General Code)

divCycleMedia = function()
{
	var oComponent = this;
	var oDefConfig =
	{
		sTabClassMedia: "productCycleTabMedia",
		sItemClass: "productCycleItemMedia",
		oParentNode: document.body,
		sSwitchEvent: "click",
		iDelayTime: 3000,
		iCycleTimes: 1,
		sCurrentClass: "current",
		sOrder: "asc"
	}

	var aTabs, aItems, oParent;
	var iDelayTime;
	var oTimer;
	var currentIndex = getid;
	var dataLength;
	var iCycleTimes = 0;
	oComponent.init = function(oConfig)
	{
		if (!oConfig && !YL.isObject(oConfig))
		{
			oConfig = {}
		}
		(YL.isString(oConfig.sTabClassMedia)) ? oDefConfig.sTabClassMedia = oConfig.sTabClassMedia : null;
		(YL.isString(oConfig.sItemClassMedia)) ? oDefConfig.sItemClassMedia = oConfig.sItemClassMedia : null;
		(YL.isObject(oConfig.oParentNode)) ? oDefConfig.oParentNode = oConfig.oParentNode : null;
		(YL.isString(oConfig.sSwitchEvent)) ? oDefConfig.sSwitchEvent = oConfig.sSwitchEvent : null;
		(YL.isNumber(oConfig.iDelayTime)) ? oDefConfig.iDelayTime = oConfig.iDelayTime : null;
		(YL.isNumber(oConfig.iCycleTimes)) ? oDefConfig.iCycleTimes = oConfig.iCycleTimes : null;
		(YL.isString(oConfig.sCurrentClass)) ? oDefConfig.sCurrentClass = oConfig.sCurrentClass : null;
		(YL.isString(oConfig.sOrder)) ? oDefConfig.sOrder = oConfig.sOrder : null;
		aTabs = YUD.getElementsByClassName(oDefConfig.sTabClassMedia, '*', oDefConfig.oParentNode);
		aItems = YUD.getElementsByClassName(oDefConfig.sItemClassMedia, '*', oDefConfig.oParentNode);
		oParent = oDefConfig.oParentNode;
		dataLength = Math.min(aTabs.length, aItems.length);

		if (oDefConfig.sOrder == "desc")
		{
			currentIndex = dataLength - 1;
		}
		YUE.on(aTabs, "mouseover", oComponent.stop);
		YUE.on(aTabs, "mouseout", oComponent.start);
		YUE.on(aItems, "mouseover", oComponent.stop);
		YUE.on(aItems, "mouseout", oComponent.start);

		for (i = 0; i < dataLength; i++)
		{
			YUE.on(aTabs[i], oDefConfig.sSwitchEvent, oComponent.show, i);
		}
		oComponent.start();
	}
	oComponent.start = function()
	{
		clearInterval(oTimer);
		oTimer = setInterval(switchItem, oDefConfig.iDelayTime);
	}
	oComponent.stop = function()
	{
		clearInterval(oTimer);
	}
	oComponent.show = function(e, iIndex)
	{
		if (!YL.isNumber(iIndex) || iIndex < 0 || iIndex >= dataLength)
		{
			return false;
		}
		currentIndex = iIndex;
		var f1 = function(element)
		{
			return YUD.removeClass(element, oDefConfig.sCurrentClass);
		}
		YUD.batch(aTabs, f1);
		YUD.addClass(aTabs[iIndex], oDefConfig.sCurrentClass);
		YUD.setStyle(aItems, "display", "none");
		YUD.setStyle(aItems[iIndex], "display", "");
	}
	var switchItem = function()
	{
		oComponent.show(null, currentIndex);

		if (iCycleTimes >= oDefConfig.iCycleTimes)
		{
			oComponent.stop();
			YUE.removeListener(aTabs, "mouseover", oComponent.stop);
			YUE.removeListener(aTabs, "mouseout", oComponent.start);
			YUE.removeListener(aItems, "mouseover", oComponent.stop);
			YUE.removeListener(aItems, "mouseout", oComponent.start);

			switch (oDefConfig.sOrder)
			{
				case ("asc"):
					{}

				case ("desc"):
					{
						break;
					}
			}
		}

		switch (oDefConfig.sOrder)
		{
			case ("asc"):
				{
					currentIndex++;

					if (currentIndex >= dataLength)
					{
						currentIndex = 1;
						iCycleTimes++;
					}
					break;
				}

			case ("desc"):
				{
					currentIndex--;

					if (currentIndex < 0)
					{
						currentIndex = dataLength - 1;
						iCycleTimes++;
					}
					break;
				}
		}
	}
}