var Prototype = {Version:"1.4.0", ScriptFragment:"(?:<script.*?>)((\n|\r|.)*?)(?:</script>)", emptyFunction:function () {
}, K:function (x) {
	return x;
}};
var Class = {create:function () {
	return function () {
		this.initialize.apply(this, arguments);
	};
}};
var Abstract = new Object();
Object.extend = function (destination, source) {
	for (property in source) {
		destination[property] = source[property];
	}
	return destination;
};
Object.inspect = function (object) {
	try {
		if (object == undefined) {
			return "undefined";
		}
		if (object == null) {
			return "null";
		}
		return object.inspect ? object.inspect() : object.toString();
	}
	catch (e) {
		if (e instanceof RangeError) {
			return "...";
		}
		throw e;
	}
};
Function.prototype.bind = function () {
	var __method = this, args = $A(arguments), object = args.shift();
	return function () {
		return __method.apply(object, args.concat($A(arguments)));
	};
};
Function.prototype.bindAsEventListener = function (object) {
	var __method = this;
	return function (event) {
		return __method.call(object, event || window.event);
	};
};
Object.extend(Number.prototype, {toColorPart:function () {
	var digits = this.toString(16);
	if (this < 16) {
		return "0" + digits;
	}
	return digits;
}, succ:function () {
	return this + 1;
}, times:function (iterator) {
	$R(0, this, true).each(iterator);
	return this;
}});
var Try = {these:function () {
	var returnValue;
	for (var i = 0; i < arguments.length; i++) {
		var lambda = arguments[i];
		try {
			returnValue = lambda();
			break;
		}
		catch (e) {
		}
	}
	return returnValue;
}};
/*--------------------------------------------------------------------------*/
function $() {
	var elements = new Array();
	for (var i = 0; i < arguments.length; i++) {
		var element = arguments[i];
		if (typeof element == "string") {
			element = document.getElementById(element);
		}
		if (arguments.length == 1) {
			return element;
		}
		elements.push(element);
	}
	return elements;
}
Object.extend(String.prototype, {stripTags:function () {
	return this.replace(/<\/?[^>]+>/gi, "");
}, stripScripts:function () {
	return this.replace(new RegExp(Prototype.ScriptFragment, "img"), "");
}, extractScripts:function () {
	var matchAll = new RegExp(Prototype.ScriptFragment, "img");
	var matchOne = new RegExp(Prototype.ScriptFragment, "im");
	return (this.match(matchAll) || []).map(function (scriptTag) {
		return (scriptTag.match(matchOne) || ["", ""])[1];
	});
}, evalScripts:function () {
	return this.extractScripts().map(eval);
}, escapeHTML:function () {
	var div = document.createElement("div");
	var text = document.createTextNode(this);
	div.appendChild(text);
	return div.innerHTML;
}, unescapeHTML:function () {
	var div = document.createElement("div");
	div.innerHTML = this.stripTags();
	return div.childNodes[0] ? div.childNodes[0].nodeValue : "";
}, toQueryParams:function () {
	var pairs = this.match(/^\??(.*)$/)[1].split("&");
	return pairs.inject({}, function (params, pairString) {
		var pair = pairString.split("=");
		params[pair[0]] = pair[1];
		return params;
	});
}, toArray:function () {
	return this.split("");
}, camelize:function () {
	var oStringList = this.split("-");
	if (oStringList.length == 1) {
		return oStringList[0];
	}
	var camelizedString = this.indexOf("-") == 0 ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1) : oStringList[0];
	for (var i = 1, len = oStringList.length; i < len; i++) {
		var s = oStringList[i];
		camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
	}
	return camelizedString;
}, inspect:function () {
	return "'" + this.replace("\\", "\\\\").replace("'", "\\'") + "'";
}});
String.prototype.parseQuery = String.prototype.toQueryParams;
var $break = new Object();
var $continue = new Object();
var Enumerable = {each:function (iterator) {
	var index = 0;
	try {
		this._each(function (value) {
			try {
				iterator(value, index++);
			}
			catch (e) {
				if (e != $continue) {
					throw e;
				}
			}
		});
	}
	catch (e) {
		if (e != $break) {
			throw e;
		}
	}
}, all:function (iterator) {
	var result = true;
	this.each(function (value, index) {
		result = result && !!(iterator || Prototype.K)(value, index);
		if (!result) {
			throw $break;
		}
	});
	return result;
}, any:function (iterator) {
	var result = true;
	this.each(function (value, index) {
		if (result = !!(iterator || Prototype.K)(value, index)) {
			throw $break;
		}
	});
	return result;
}, collect:function (iterator) {
	var results = [];
	this.each(function (value, index) {
		results.push(iterator(value, index));
	});
	return results;
}, detect:function (iterator) {
	var result;
	this.each(function (value, index) {
		if (iterator(value, index)) {
			result = value;
			throw $break;
		}
	});
	return result;
}, findAll:function (iterator) {
	var results = [];
	this.each(function (value, index) {
		if (iterator(value, index)) {
			results.push(value);
		}
	});
	return results;
}, grep:function (pattern, iterator) {
	var results = [];
	this.each(function (value, index) {
		var stringValue = value.toString();
		if (stringValue.match(pattern)) {
			results.push((iterator || Prototype.K)(value, index));
		}
	});
	return results;
}, include:function (object) {
	var found = false;
	this.each(function (value) {
		if (value == object) {
			found = true;
			throw $break;
		}
	});
	return found;
}, inject:function (memo, iterator) {
	this.each(function (value, index) {
		memo = iterator(memo, value, index);
	});
	return memo;
}, invoke:function (method) {
	var args = $A(arguments).slice(1);
	return this.collect(function (value) {
		return value[method].apply(value, args);
	});
}, max:function (iterator) {
	var result;
	this.each(function (value, index) {
		value = (iterator || Prototype.K)(value, index);
		if (value >= (result || value)) {
			result = value;
		}
	});
	return result;
}, min:function (iterator) {
	var result;
	this.each(function (value, index) {
		value = (iterator || Prototype.K)(value, index);
		if (value <= (result || value)) {
			result = value;
		}
	});
	return result;
}, partition:function (iterator) {
	var trues = [], falses = [];
	this.each(function (value, index) {
		((iterator || Prototype.K)(value, index) ? trues : falses).push(value);
	});
	return [trues, falses];
}, pluck:function (property) {
	var results = [];
	this.each(function (value, index) {
		results.push(value[property]);
	});
	return results;
}, reject:function (iterator) {
	var results = [];
	this.each(function (value, index) {
		if (!iterator(value, index)) {
			results.push(value);
		}
	});
	return results;
}, sortBy:function (iterator) {
	return this.collect(function (value, index) {
		return {value:value, criteria:iterator(value, index)};
	}).sort(function (left, right) {
		var a = left.criteria, b = right.criteria;
		return a < b ? -1 : a > b ? 1 : 0;
	}).pluck("value");
}, toArray:function () {
	return this.collect(Prototype.K);
}, zip:function () {
	var iterator = Prototype.K, args = $A(arguments);
	if (typeof args.last() == "function") {
		iterator = args.pop();
	}
	var collections = [this].concat(args).map($A);
	return this.map(function (value, index) {
		iterator(value = collections.pluck(index));
		return value;
	});
}, inspect:function () {
	return "#<Enumerable:" + this.toArray().inspect() + ">";
}};
Object.extend(Enumerable, {map:Enumerable.collect, find:Enumerable.detect, select:Enumerable.findAll, member:Enumerable.include, entries:Enumerable.toArray});
var $A = Array.from = function (iterable) {
	if (!iterable) {
		return [];
	}
	if (iterable.toArray) {
		return iterable.toArray();
	} else {
		var results = [];
		for (var i = 0; i < iterable.length; i++) {
			results.push(iterable[i]);
		}
		return results;
	}
};
Object.extend(Array.prototype, Enumerable);
Array.prototype._reverse = Array.prototype.reverse;
Object.extend(Array.prototype, {_each:function (iterator) {
	for (var i = 0; i < this.length; i++) {
		iterator(this[i]);
	}
}, clear:function () {
	this.length = 0;
	return this;
}, first:function () {
	return this[0];
}, last:function () {
	return this[this.length - 1];
}, compact:function () {
	return this.select(function (value) {
		return value != undefined || value != null;
	});
}, flatten:function () {
	return this.inject([], function (array, value) {
		return array.concat(value.constructor == Array ? value.flatten() : [value]);
	});
}, without:function () {
	var values = $A(arguments);
	return this.select(function (value) {
		return !values.include(value);
	});
}, indexOf:function (object) {
	for (var i = 0; i < this.length; i++) {
		if (this[i] == object) {
			return i;
		}
	}
	return -1;
}, reverse:function (inline) {
	return (inline !== false ? this : this.toArray())._reverse();
}, shift:function () {
	var result = this[0];
	for (var i = 0; i < this.length - 1; i++) {
		this[i] = this[i + 1];
	}
	this.length--;
	return result;
}, inspect:function () {
	return "[" + this.map(Object.inspect).join(", ") + "]";
}});
var Hash = {_each:function (iterator) {
	for (key in this) {
		var value = this[key];
		if (typeof value == "function") {
			continue;
		}
		var pair = [key, value];
		pair.key = key;
		pair.value = value;
		iterator(pair);
	}
}, keys:function () {
	return this.pluck("key");
}, values:function () {
	return this.pluck("value");
}, merge:function (hash) {
	return $H(hash).inject($H(this), function (mergedHash, pair) {
		mergedHash[pair.key] = pair.value;
		return mergedHash;
	});
}, toQueryString:function () {
	return this.map(function (pair) {
		return pair.map(encodeURIComponent).join("=");
	}).join("&");
}, inspect:function () {
	return "#<Hash:{" + this.map(function (pair) {
		return pair.map(Object.inspect).join(": ");
	}).join(", ") + "}>";
}};
function $H(object) {
	var hash = Object.extend({}, object || {});
	Object.extend(hash, Enumerable);
	Object.extend(hash, Hash);
	return hash;
}
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {initialize:function (start, end, exclusive) {
	this.start = start;
	this.end = end;
	this.exclusive = exclusive;
}, _each:function (iterator) {
	var value = this.start;
	do {
		iterator(value);
		value = value.succ();
	} while (this.include(value));
}, include:function (value) {
	if (value < this.start) {
		return false;
	}
	if (this.exclusive) {
		return value < this.end;
	}
	return value <= this.end;
}});
var $R = function (start, end, exclusive) {
	return new ObjectRange(start, end, exclusive);
};
var Ajax = {getTransport:function () {
	return Try.these(function () {
		return new ActiveXObject("Msxml2.XMLHTTP");
	}, function () {
		return new ActiveXObject("Microsoft.XMLHTTP");
	}, function () {
		return new XMLHttpRequest();
	}) || false;
}, activeRequestCount:0};
Ajax.Responders = {responders:[], _each:function (iterator) {
	this.responders._each(iterator);
}, register:function (responderToAdd) {
	if (!this.include(responderToAdd)) {
		this.responders.push(responderToAdd);
	}
}, unregister:function (responderToRemove) {
	this.responders = this.responders.without(responderToRemove);
}, dispatch:function (callback, request, transport, json) {
	this.each(function (responder) {
		if (responder[callback] && typeof responder[callback] == "function") {
			try {
				responder[callback].apply(responder, [request, transport, json]);
			}
			catch (e) {
			}
		}
	});
}};
Object.extend(Ajax.Responders, Enumerable);
Ajax.Responders.register({onCreate:function () {
	Ajax.activeRequestCount++;
}, onComplete:function () {
	Ajax.activeRequestCount--;
}});
Ajax.Base = function () {
};
Ajax.Base.prototype = {setOptions:function (options) {
	this.options = {method:"post", asynchronous:true, parameters:""};
	Object.extend(this.options, options || {});
}, responseIsSuccess:function () {
	return this.transport.status == undefined || this.transport.status == 0 || (this.transport.status >= 200 && this.transport.status < 300);
}, responseIsFailure:function () {
	return !this.responseIsSuccess();
}};
Ajax.Request = Class.create();
Ajax.Request.Events = ["Uninitialized", "Loading", "Loaded", "Interactive", "Complete"];
Ajax.Request.prototype = Object.extend(new Ajax.Base(), {initialize:function (url, options) {
	this.transport = Ajax.getTransport();
	this.setOptions(options);
	this.request(url);
}, request:function (url) {
	var parameters = this.options.parameters || "";
	if (parameters.length > 0) {
		parameters += "&_=";
	}
	try {
		this.url = url;
		if (this.options.method == "get" && parameters.length > 0) {
			this.url += (this.url.match(/\?/) ? "&" : "?") + parameters;
		}
		Ajax.Responders.dispatch("onCreate", this, this.transport);
		this.transport.open(this.options.method, this.url, this.options.asynchronous);
		if (this.options.asynchronous) {
			this.transport.onreadystatechange = this.onStateChange.bind(this);
			setTimeout((function () {
				this.respondToReadyState(1);
			}).bind(this), 10);
		}
		this.setRequestHeaders();
		var body = this.options.postBody ? this.options.postBody : parameters;
		this.transport.send(this.options.method == "post" ? body : null);
	}
	catch (e) {
		this.dispatchException(e);
	}
}, setRequestHeaders:function () {
	var requestHeaders = ["X-Requested-With", "XMLHttpRequest", "X-Prototype-Version", Prototype.Version];
	if (this.options.method == "post") {
		requestHeaders.push("Content-type", "application/x-www-form-urlencoded");
		/* Force "Connection: close" for Mozilla browsers to work around
       * a bug where XMLHttpReqeuest sends an incorrect Content-length
       * header. See Mozilla Bugzilla #246651.
       */
		if (this.transport.overrideMimeType) {
			requestHeaders.push("Connection", "close");
		}
	}
	if (this.options.requestHeaders) {
		requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
	}
	for (var i = 0; i < requestHeaders.length; i += 2) {
		this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i + 1]);
	}
}, onStateChange:function () {
	var readyState = this.transport.readyState;
	if (readyState != 1) {
		this.respondToReadyState(this.transport.readyState);
	}
}, header:function (name) {
	try {
		return this.transport.getResponseHeader(name);
	}
	catch (e) {
	}
}, evalJSON:function () {
	try {
		return eval(this.header("X-JSON"));
	}
	catch (e) {
	}
}, evalResponse:function () {
	try {
		return eval(this.transport.responseText);
	}
	catch (e) {
		this.dispatchException(e);
	}
}, respondToReadyState:function (readyState) {
	var event = Ajax.Request.Events[readyState];
	var transport = this.transport, json = this.evalJSON();
	if (event == "Complete") {
		try {
			(this.options["on" + this.transport.status] || this.options["on" + (this.responseIsSuccess() ? "Success" : "Failure")] || Prototype.emptyFunction)(transport, json);
		}
		catch (e) {
			this.dispatchException(e);
		}
		if ((this.header("Content-type") || "").match(/^text\/javascript/i)) {
			this.evalResponse();
		}
	}
	try {
		(this.options["on" + event] || Prototype.emptyFunction)(transport, json);
		Ajax.Responders.dispatch("on" + event, this, transport, json);
	}
	catch (e) {
		this.dispatchException(e);
	}
	/* Avoid memory leak in MSIE: clean up the oncomplete event handler */
	if (event == "Complete") {
		this.transport.onreadystatechange = Prototype.emptyFunction;
	}
}, dispatchException:function (exception) {
	(this.options.onException || Prototype.emptyFunction)(this, exception);
	Ajax.Responders.dispatch("onException", this, exception);
}});
Ajax.Updater = Class.create();
Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {initialize:function (container, url, options) {
	this.containers = {success:container.success ? $(container.success) : $(container), failure:container.failure ? $(container.failure) : (container.success ? null : $(container))};
	this.transport = Ajax.getTransport();
	this.setOptions(options);
	var onComplete = this.options.onComplete || Prototype.emptyFunction;
	this.options.onComplete = (function (transport, object) {
		this.updateContent();
		onComplete(transport, object);
	}).bind(this);
	this.request(url);
}, updateContent:function () {
	var receiver = this.responseIsSuccess() ? this.containers.success : this.containers.failure;
	var response = this.transport.responseText;
	if (!this.options.evalScripts) {
		response = response.stripScripts();
	}
	if (receiver) {
		if (this.options.insertion) {
			new this.options.insertion(receiver, response);
		} else {
			Element.update(receiver, response);
		}
	}
	if (this.responseIsSuccess()) {
		if (this.onComplete) {
			setTimeout(this.onComplete.bind(this), 10);
		}
	}
}});
Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {initialize:function (container, url, options) {
	this.setOptions(options);
	this.onComplete = this.options.onComplete;
	this.frequency = (this.options.frequency || 2);
	this.decay = (this.options.decay || 1);
	this.updater = {};
	this.container = container;
	this.url = url;
	this.start();
}, start:function () {
	this.options.onComplete = this.updateComplete.bind(this);
	this.onTimerEvent();
}, stop:function () {
	this.updater.onComplete = undefined;
	clearTimeout(this.timer);
	(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
}, updateComplete:function (request) {
	if (this.options.decay) {
		this.decay = (request.responseText == this.lastText ? this.decay * this.options.decay : 1);
		this.lastText = request.responseText;
	}
	this.timer = setTimeout(this.onTimerEvent.bind(this), this.decay * this.frequency * 1000);
}, onTimerEvent:function () {
	this.updater = new Ajax.Updater(this.container, this.url, this.options);
}});
document.getElementsByClassName = function (className, parentElement) {
	var children = ($(parentElement) || document.body).getElementsByTagName("*");
	return $A(children).inject([], function (elements, child) {
		if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)"))) {
			elements.push(child);
		}
		return elements;
	});
};
function selrecommendorhot(value) {
	switch (value) {
	  case 1:
		$("li_recommend").className = "on";
		$("li_hot").className = "";
		$("div_recommend").style.display = "block";
		$("div_hot").style.display = "none";
		break;
	  case 2:
		$("li_recommend").className = "";
		$("li_hot").className = "on";
		$("div_recommend").style.display = "none";
		$("div_hot").style.display = "block";
		break;
	  default:
		break;
	}
}
function selmanorwoman(value) {
	switch (value) {
	  case 1:
		$("li_man").className = "on";
		$("li_woman").className = "";
		$("div_man").style.display = "block";
		$("div_woman").style.display = "none";
		break;
	  case 2:
		$("li_man").className = "";
		$("li_woman").className = "on";
		$("div_man").style.display = "none";
		$("div_woman").style.display = "block";
		break;
	  default:
		break;
	}
}
var newmanindex = 0;
var hotmanindex = 0;
var newwomanindex = 0;
var hotwomanindex = 0;
function selproman(obj, x, y, index) {
var ids = obj.id ;
var lis = obj.parentNode.getElementsByTagName('li');

for(var i=0;i<lis.length;i++){
	if(lis[i].id.indexOf('over')>=0){
		lis[i].style.display = 'none';
	}else{
		lis[i].style.display = 'block';
	}
}
obj.style.display = 'none';
document.getElementById(ids.replace('li_hotman_','li_hotman_over_')).style.display='block';

/**
	switch (y) {
	  case 1:
		switch (x) {
		  case 1:
		  
			var newover = document.getElementById("li_newman_over_" + index);
			var oldover = document.getElementById("li_newman_over_" + newmanindex);
			var old = document.getElementById("li_newman_" + newmanindex);
			newover.style.display = "block";
			oldover.style.display = "none";
			old.style.display = "block";
			obj.style.display = "none";
			newmanindex = index;
			break;
		  case 2:
			var newover = document.getElementById("li_hotman_over_" + index);
			var oldover = document.getElementById("li_hotman_over_" + hotmanindex);
			var old = document.getElementById("li_hotman_" + hotmanindex);
			newover.style.display = "block";
			oldover.style.display = "none";
			old.style.display = "block";
			obj.style.display = "none";
			hotmanindex = index;
			break;
		  default:
			break;
		}
		break;
	  case 2:
		switch (x) {
		  case 1:
			var newover = document.getElementById("li_newwoman_over_" + index);
			var oldover = document.getElementById("li_newwoman_over_" + newwomanindex);
			var old = document.getElementById("li_newwoman_" + newwomanindex);
			newover.style.display = "block";
			oldover.style.display = "none";
			old.style.display = "block";
			obj.style.display = "none";
			newwomanindex = index;
			break;
		  case 2:
			var newover = document.getElementById("li_hotwoman_over_" + index);
			var oldover = document.getElementById("li_hotwoman_over_" + hotwomanindex);
			var old = document.getElementById("li_hotwoman_" + hotwomanindex);
			newover.style.display = "block";
			oldover.style.display = "none";
			old.style.display = "block";
			obj.style.display = "none";
			hotwomanindex = index;
			break;
		  default:
			break;
		}
		break;
	  default:
		break;
	}**/
}