text: /*
  Manipulator v0.9.3-parentnode-skin-default Copyright 2019 https://manipulator.parentnode.dk
  js-merged @ 2020-03-16 10:21:42
  */
  
  /*seg_mobile_include.js*/
  
  /*u.js*/
  if(!u || !Util) {
  	var u, Util = u = new function() {};
  	u.version = "0.9.3";
  	u.bug = u.nodeId = u.exception = function() {};
  	u.stats = new function() {this.pageView = function(){};this.event = function(){};}
  	u.txt = function(index) {return index;}
  }
  function fun(v) {return (typeof(v) === "function")}
  function obj(v) {return (typeof(v) === "object")}
  function str(v) {return (typeof(v) === "string")}
  
  /*u-debug.js*/
  u.bug_console_only = true;
  Util.debugURL = function(url) {
  	if(u.bug_force) {
  		return true;
  	}
  	return document.domain.match(/(\.local|\.proxy)$/);
  }
  Util.nodeId = function(node, include_path) {
  	console.log("Util.nodeId IS DEPRECATED. Use commas in u.bug in stead.");
  	console.log(arguments.callee.caller);
  	try {
  		if(!include_path) {
  			return node.id ? node.nodeName+"#"+node.id : (node.className ? node.nodeName+"."+node.className : (node.name ? node.nodeName + "["+node.name+"]" : node.nodeName));
  		}
  		else {
  			if(node.parentNode && node.parentNode.nodeName != "HTML") {
  				return u.nodeId(node.parentNode, include_path) + "->" + u.nodeId(node);
  			}
  			else {
  				return u.nodeId(node);
  			}
  		}
  	}
  	catch(exception) {
  		u.exception("u.nodeId", arguments, exception);
  	}
  	return "Unindentifiable node!";
  }
  Util.exception = function(name, _arguments, _exception) {
  	u.bug("Exception in: " + name + " (" + _exception + ")");
  	console.error(_exception);
  	u.bug("Invoked with arguments:");
  	console.log(_arguments);
  	// 
  	// 
  }
  Util.bug = function() {
  	if(u.debugURL()) {
  		if(!u.bug_console_only) {
  			var i, message;
  			if(obj(console)) {
  				for(i = 0; i < arguments.length; i++) {
  					if(arguments[i] || typeof(arguments[i]) == "undefined") {
  						console.log(arguments[i]);
  					}
  				}
  			}
  			var option, options = new Array([0, "auto", "auto", 0], [0, 0, "auto", "auto"], ["auto", 0, 0, "auto"], ["auto", "auto", 0, 0]);
  			var corner = u.bug_corner ? u.bug_corner : 0;
  			var color = u.bug_color ? u.bug_color : "black";
  			option = options[corner];
  			if(!document.getElementById("debug_id_"+corner)) {
  				var d_target = u.ae(document.body, "div", {"class":"debug_"+corner, "id":"debug_id_"+corner});
  				d_target.style.position = u.bug_position ? u.bug_position : "absolute";
  				d_target.style.zIndex = 16000;
  				d_target.style.top = option[0];
  				d_target.style.right = option[1];
  				d_target.style.bottom = option[2];
  				d_target.style.left = option[3];
  				d_target.style.backgroundColor = u.bug_bg ? u.bug_bg : "#ffffff";
  				d_target.style.color = "#000000";
  				d_target.style.fontSize = "11px";
  				d_target.style.lineHeight = "11px";
  				d_target.style.textAlign = "left";
  				if(d_target.style.maxWidth) {
  					d_target.style.maxWidth = u.bug_max_width ? u.bug_max_width+"px" : "auto";
  				}
  				d_target.style.padding = "2px 3px";
  			}
  			for(i = 0; i < arguments.length; i++) {
  				if(arguments[i] === undefined) {
  					message = "undefined";
  				}
  				else if(!str(arguments[i]) && fun(arguments[i].toString)) {
  					message = arguments[i].toString();
  				}
  				else {
  					message = arguments[i];
  				}
  				var debug_div = document.getElementById("debug_id_"+corner);
  				message = message ? message.replace(/\>/g, "&gt;").replace(/\</g, "&lt;").replace(/&lt;br&gt;/g, "<br>") : "Util.bug with no message?";
  				u.ae(debug_div, "div", {"style":"color: " + color, "html": message});
  			}
  		}
  		else if(typeof(console) !== "undefined" && obj(console)) {
  			var i;
  			for(i = 0; i < arguments.length; i++) {
  				console.log(arguments[i]);
  			}
  		}
  	}
  }
  Util.xInObject = function(object, _options) {
  	if(u.debugURL()) {
  		var return_string = false;
  		var explore_objects = false;
  		if(obj(_options)) {
  			var _argument;
  			for(_argument in _options) {
  				switch(_argument) {
  					case "return"     : return_string               = _options[_argument]; break;
  					case "objects"    : explore_objects             = _options[_argument]; break;
  				}
  			}
  		}
  		var x, s = "--- start object ---\n";
  		for(x in object) {
  			if(explore_objects && object[x] && obj(object[x]) && !str(object[x].nodeName)) {
  				s += x + "=" + object[x]+" => \n";
  				s += u.xInObject(object[x], true);
  			}
  			else if(object[x] && obj(object[x]) && str(object[x].nodeName)) {
  				s += x + "=" + object[x]+" -> " + u.nodeId(object[x], 1) + "\n";
  			}
  			else if(object[x] && fun(object[x])) {
  				s += x + "=function\n";
  			}
  			else {
  				s += x + "=" + object[x]+"\n";
  			}
  		}
  		s += "--- end object ---\n";
  		if(return_string) {
  			return s;
  		}
  		else {
  			u.bug(s);
  		}
  	}
  }
  
  
  /*u-cookie.js*/
  Util.saveCookie = function(name, value, _options) {
  	var expires = true;
  	var path = false;
  	var force = false;
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "expires"	: expires	= _options[_argument]; break;
  				case "path"		: path		= _options[_argument]; break;
  				case "force"	: force		= _options[_argument]; break;
  			}
  		}
  	}
  	if(!force && obj(window.localStorage) && obj(window.sessionStorage)) {
  		if(expires === true) {
  			window.sessionStorage.setItem(name, value);
  		}
  		else {
  			window.localStorage.setItem(name, value);
  		}
  		return;
  	}
  	if(expires === false) {
  		expires = ";expires=Mon, 04-Apr-2020 05:00:00 GMT";
  	}
  	else if(str(expires)) {
  		expires = ";expires="+expires;
  	}
  	else {
  		expires = "";
  	}
  	if(str(path)) {
  		path = ";path="+path;
  	}
  	else {
  		path = "";
  	}
  	document.cookie = encodeURIComponent(name) + "=" + encodeURIComponent(value) + path + expires;
  }
  Util.getCookie = function(name) {
  	var matches;
  	if(obj(window.sessionStorage) && window.sessionStorage.getItem(name)) {
  		return window.sessionStorage.getItem(name)
  	}
  	else if(obj(window.localStorage) && window.localStorage.getItem(name)) {
  		return window.localStorage.getItem(name)
  	}
  	return (matches = document.cookie.match(encodeURIComponent(name) + "=([^;]+)")) ? decodeURIComponent(matches[1]) : false;
  }
  Util.deleteCookie = function(name, _options) {
  	var path = false;
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "path"	: path	= _options[_argument]; break;
  			}
  		}
  	}
  	if(obj(window.sessionStorage)) {
  		window.sessionStorage.removeItem(name);
  	}
  	if(obj(window.localStorage)) {
  		window.localStorage.removeItem(name);
  	}
  	if(str(path)) {
  		path = ";path="+path;
  	}
  	else {
  		path = "";
  	}
  	document.cookie = encodeURIComponent(name) + "=" + path + ";expires=Thu, 01-Jan-70 00:00:01 GMT";
  }
  Util.saveNodeCookie = function(node, name, value, _options) {
  	var ref = u.cookieReference(node, _options);
  	var mem = JSON.parse(u.getCookie("man_mem"));
  	if(!mem) {
  		mem = {};
  	}
  	if(!mem[ref]) {
  		mem[ref] = {};
  	}
  	mem[ref][name] = (value !== false && value !== undefined) ? value : "";
  	u.saveCookie("man_mem", JSON.stringify(mem), {"path":"/"});
  }
  Util.getNodeCookie = function(node, name, _options) {
  	var ref = u.cookieReference(node, _options);
  	var mem = JSON.parse(u.getCookie("man_mem"));
  	if(mem && mem[ref]) {
  		if(name) {
  			return mem[ref][name] ? mem[ref][name] : "";
  		}
  		else {
  			return mem[ref];
  		}
  	}
  	return false;
  }
  Util.deleteNodeCookie = function(node, name, _options) {
  	var ref = u.cookieReference(node, _options);
  	var mem = JSON.parse(u.getCookie("man_mem"));
  	if(mem && mem[ref]) {
  		if(name) {
  			delete mem[ref][name];
  		}
  		else {
  			delete mem[ref];
  		}
  	}
  	u.saveCookie("man_mem", JSON.stringify(mem), {"path":"/"});
  }
  Util.cookieReference = function(node, _options) {
  	var ref;
  	var ignore_classnames = false;
  	var ignore_classvars = false;
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "ignore_classnames"	: ignore_classnames	= _options[_argument]; break;
  				case "ignore_classvars" 	: ignore_classvars	= _options[_argument]; break;
  			}
  		}
  	}
  	if(node.id) {
  		ref = node.nodeName + "#" + node.id;
  	}
  	else {
  		var node_identifier = "";
  		if(node.name) {
  			node_identifier = node.nodeName + "["+node.name+"]";
  		}
  		else if(node.className) {
  			var classname = node.className;
  			if(ignore_classnames) {
  				var regex = new RegExp("(^| )("+ignore_classnames.split(",").join("|")+")($| )", "g");
  				classname = classname.replace(regex, " ").replace(/[ ]{2,4}/, " ");
  			}
  			if(ignore_classvars) {
  				classname = classname.replace(/\b[a-zA-Z_]+\:[\?\=\w\/\\#~\:\.\,\+\&\%\@\!\-]+\b/g, "").replace(/[ ]{2,4}/g, " ");
  			}
  			node_identifier = node.nodeName+"."+classname.trim().replace(/ /g, ".");
  		}
  		else {
  			node_identifier = node.nodeName
  		}
  		var id_node = node;
  		while(!id_node.id) {
  			id_node = id_node.parentNode;
  		}
  		if(id_node.id) {
  			ref = id_node.nodeName + "#" + id_node.id + " " + node_identifier;
  		}
  		else {
  			ref = node_identifier;
  		}
  	}
  	return ref;
  }
  
  
  /*u-dom.js*/
  Util.querySelector = u.qs = function(query, scope) {
  	scope = scope ? scope : document;
  	return scope.querySelector(query);
  }
  Util.querySelectorAll = u.qsa = function(query, scope) {
  	try {
  		scope = scope ? scope : document;
  		return scope.querySelectorAll(query);
  	}
  	catch(exception) {
  		u.exception("u.qsa", arguments, exception);
  	}
  	return [];
  }
  Util.getElement = u.ge = function(identifier, scope) {
  	var node, nodes, i, regexp;
  	if(document.getElementById(identifier)) {
  		return document.getElementById(identifier);
  	}
  	scope = scope ? scope : document;
  	regexp = new RegExp("(^|\\s)" + identifier + "(\\s|$|\:)");
  	nodes = scope.getElementsByTagName("*");
  	for(i = 0; i < nodes.length; i++) {
  		node = nodes[i];
  		if(regexp.test(node.className)) {
  			return node;
  		}
  	}
  	return scope.getElementsByTagName(identifier).length ? scope.getElementsByTagName(identifier)[0] : false;
  }
  Util.getElements = u.ges = function(identifier, scope) {
  	var node, nodes, i, regexp;
  	var return_nodes = new Array();
  	scope = scope ? scope : document;
  	regexp = new RegExp("(^|\\s)" + identifier + "(\\s|$|\:)");
  	nodes = scope.getElementsByTagName("*");
  	for(i = 0; i < nodes.length; i++) {
  		node = nodes[i];
  		if(regexp.test(node.className)) {
  			return_nodes.push(node);
  		}
  	}
  	return return_nodes.length ? return_nodes : scope.getElementsByTagName(identifier);
  }
  Util.parentNode = u.pn = function(node, _options) {
  	var exclude = "";
  	var include = "";
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "include"      : include       = _options[_argument]; break;
  				case "exclude"      : exclude       = _options[_argument]; break;
  			}
  		}
  	}
  	var exclude_nodes = exclude ? u.qsa(exclude) : [];
  	var include_nodes = include ? u.qsa(include) : [];
  	node = node.parentNode;
  	while(node && (node.nodeType == 3 || node.nodeType == 8 || (exclude && (u.inNodeList(node, exclude_nodes))) || (include && (!u.inNodeList(node, include_nodes))))) {
  		node = node.parentNode;
  	}
  	return node;
  }
  Util.previousSibling = u.ps = function(node, _options) {
  	var exclude = "";
  	var include = "";
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "include"      : include       = _options[_argument]; break;
  				case "exclude"      : exclude       = _options[_argument]; break;
  			}
  		}
  	}
  	var exclude_nodes = exclude ? u.qsa(exclude, node.parentNode) : [];
  	var include_nodes = include ? u.qsa(include, node.parentNode) : [];
  	node = node.previousSibling;
  	while(node && (node.nodeType == 3 || node.nodeType == 8 || (exclude && (u.inNodeList(node, exclude_nodes))) || (include && (!u.inNodeList(node, include_nodes))))) {
  		node = node.previousSibling;
  	}
  	return node;
  }
  Util.nextSibling = u.ns = function(node, _options) {
  	var exclude = "";
  	var include = "";
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "include"      : include       = _options[_argument]; break;
  				case "exclude"      : exclude       = _options[_argument]; break;
  			}
  		}
  	}
  	var exclude_nodes = exclude ? u.qsa(exclude, node.parentNode) : [];
  	var include_nodes = include ? u.qsa(include, node.parentNode) : [];
  	node = node.nextSibling;
  	while(node && (node.nodeType == 3 || node.nodeType == 8 || (exclude && (u.inNodeList(node, exclude_nodes))) || (include && (!u.inNodeList(node, include_nodes))))) {
  		node = node.nextSibling;
  	}
  	return node;
  }
  Util.childNodes = u.cn = function(node, _options) {
  	var exclude = "";
  	var include = "";
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "include"      : include       = _options[_argument]; break;
  				case "exclude"      : exclude       = _options[_argument]; break;
  			}
  		}
  	}
  	var exclude_nodes = exclude ? u.qsa(exclude, node) : [];
  	var include_nodes = include ? u.qsa(include, node) : [];
  	var i, child;
  	var children = new Array();
  	for(i = 0; i < node.childNodes.length; i++) {
  		child = node.childNodes[i]
  		if(child && child.nodeType != 3 && child.nodeType != 8 && (!exclude || (!u.inNodeList(child, exclude_nodes))) && (!include || (u.inNodeList(child, include_nodes)))) {
  			children.push(child);
  		}
  	}
  	return children;
  }
  Util.appendElement = u.ae = function(_parent, node_type, attributes) {
  	try {
  		var node = (obj(node_type)) ? node_type : (node_type == "svg" ? document.createElementNS("http://www.w3.org/2000/svg", node_type) : document.createElement(node_type));
  		node = _parent.appendChild(node);
  		if(attributes) {
  			var attribute;
  			for(attribute in attributes) {
  				if(attribute == "html") {
  					node.innerHTML = attributes[attribute];
  				}
  				else {
  					node.setAttribute(attribute, attributes[attribute]);
  				}
  			}
  		}
  		return node;
  	}
  	catch(exception) {
  		u.exception("u.ae", arguments, exception);
  	}
  	return false;
  }
  Util.insertElement = u.ie = function(_parent, node_type, attributes) {
  	try {
  		var node = (obj(node_type)) ? node_type : (node_type == "svg" ? document.createElementNS("http://www.w3.org/2000/svg", node_type) : document.createElement(node_type));
  		node = _parent.insertBefore(node, _parent.firstChild);
  		if(attributes) {
  			var attribute;
  			for(attribute in attributes) {
  				if(attribute == "html") {
  					node.innerHTML = attributes[attribute];
  				}
  				else {
  					node.setAttribute(attribute, attributes[attribute]);
  				}
  			}
  		}
  		return node;
  	}
  	catch(exception) {
  		u.exception("u.ie", arguments, exception);
  	}
  	return false;
  }
  Util.wrapElement = u.we = function(node, node_type, attributes) {
  	try {
  		var wrapper_node = node.parentNode.insertBefore(document.createElement(node_type), node);
  		if(attributes) {
  			var attribute;
  			for(attribute in attributes) {
  				wrapper_node.setAttribute(attribute, attributes[attribute]);
  			}
  		}	
  		wrapper_node.appendChild(node);
  		return wrapper_node;
  	}
  	catch(exception) {
  		u.exception("u.we", arguments, exception);
  	}
  	return false;
  }
  Util.wrapContent = u.wc = function(node, node_type, attributes) {
  	try {
  		var wrapper_node = document.createElement(node_type);
  		if(attributes) {
  			var attribute;
  			for(attribute in attributes) {
  				wrapper_node.setAttribute(attribute, attributes[attribute]);
  			}
  		}	
  		while(node.childNodes.length) {
  			wrapper_node.appendChild(node.childNodes[0]);
  		}
  		node.appendChild(wrapper_node);
  		return wrapper_node;
  	}
  	catch(exception) {
  		u.exception("u.wc", arguments, exception);
  	}
  	return false;
  }
  Util.textContent = u.text = function(node) {
  	try {
  		return node.textContent;
  	}
  	catch(exception) {
  		u.exception("u.text", arguments, exception);
  	}
  	return "";
  }
  Util.clickableElement = u.ce = function(node, _options) {
  	node._use_link = "a";
  	node._click_type = "manual";
  	if(obj(_options)) {
  		var _argument;
  		for(_argument in _options) {
  			switch(_argument) {
  				case "use"			: node._use_link		= _options[_argument]; break;
  				case "type"			: node._click_type		= _options[_argument]; break;
  			}
  		}
  	}
  	var a = (node.nodeName.toLowerCase() == "a" ? node : u.qs(node._use_link, node));
  	if(a) {
  		u.ac(node, "link");
  		if(a.getAttribute("href") !== null) {
  			node.url = a.href;
  			a.removeAttribute("href");
  			node._a = a;
  		}
  	}
  	else {
  		u.ac(node, "clickable");
  	}
  	if(obj(u.e) && fun(u.e.click)) {
  		u.e.click(node, _options);
  		if(node._click_type == "link") {
  			node.clicked = function(event) {
  				if(fun(node.preClicked)) {
  					node.preClicked();
  				}
  				if(event && (event.metaKey || event.ctrlKey || (this._a && this._a.target))) {
  					window.open(this.url);
  				}
  				else {
  					if(obj(u.h) && u.h.is_listening) {
  						u.h.navigate(this.url, this);
  					}
  					else {
  						location.href = this.url;
  					}
  				}
  			}
  		}
  	}
  	return node;
  }
  Util.classVar = u.cv = function(node, var_name) {
  	try {
  		var regexp = new RegExp("(\^| )" + var_name + ":[?=\\w/\\#~:.,?+=?&%@!\\-]*");
  		var match = node.className.match(regexp);
  		if(match) {
  			return match[0].replace(var_name + ":", "").trim();
  		}
  	}
  	catch(exception) {
  		u.exception("u.cv", arguments, exception);
  	}
  	return false;
  }
  Util.setClass = u.sc = function(node, classname, dom_update) {
  	var old_class;
  	if(node instanceof SVGElement) {
  		old_class = node.className.baseVal;
  		node.setAttribute("class", classname);
  	}
  	else {
  		old_class = node.className;
  		node.className = classname;
  	}
  	dom_update = (dom_update === false) || (node.offsetTop);
  	return old_class;
  }
  Util.hasClass = u.hc = function(node, classname) {
  	if(node.classList.contains(classname)) {
  		return true;
  	}
  	else {
  		var regexp = new RegExp("(^|\\s)(" + classname + ")(\\s|$)");
  		if(node instanceof SVGElement) {
  			if(regexp.test(node.className.baseVal)) {
  				return true;
  			}
  		}
  		else {
  			if(regexp.test(node.className)) {
  				return true;
  			}
  		}
  	}
  	return false;
  }
  Util.addClass = u.ac = function(node, classname, dom_update) {
  	var classnames = classname.split(" ");
  	while(classnames.length) {
  		node.classList.add(classnames.shift());
  	}
  	dom_update = (dom_update === false) || (node.offsetTop);
  	return node.className;
  }
  Util.removeClass = u.rc = function(node, classname, dom_update) {
  	if(node.classList.contains(classname)) {
  		node.classList.remove(classname);
  	}
  	else {
  		var regexp = new RegExp("(^|\\s)(" + classname + ")(?=[\\s]|$)", "g");
  		if(node instanceof SVGElement) {
  			node.setAttribute("class", node.className.baseVal.replace(regexp, " ").trim().replace(/[\s]{2}/g, " "));
  		}
  		else {
  			node.className = node.className.replace(regexp, " ").trim().replace(/[\s]{2}/g, " ");
  		}
  	}
  	dom_update = (dom_update === false) || (node.offsetTop);
  	return node.className;
  }
  Util.toggleClass = u.tc = function(node, classname, _classname, dom_update) {
  	if(u.hc(node, classname)) {
  		u.rc(node, classname, dom_update);
  		if(_classname) {
  			u.ac(node, _classname, dom_update);
  		}
  	}
  	else {
  		u.ac(node, classname);
  		if(_classname) {
  			u.rc(node, _classname, dom_update);
  		}
  	}
  	dom_update = (dom_update === false) || (node.offsetTop);
  	return node.className;
  }
  Util.applyStyle = u.as = function(node, property, value, dom_update) {
  	node.style[u.vendorProperty(property)] = value;
  	dom_update = (dom_update === false) || (node.offsetTop);
  }
  Util.applyStyles = u.ass = function(node, styles, dom_update) {
  	if(styles) {
  		var style;
  		for(style in styles) {
  			if(obj(u.a) && style == "transition") {
  				u.a.transition(node, styles[style]);
  			}
  			else {
  				node.style[u.vendorProperty(style)] = styles[style];
  			}
  		}
  	}
  	dom_update = (dom_update === false) || (node.offsetTop);
  }
  Util.getComputedStyle = u.gcs = function(node, property) {
  	var dom_update = node.offsetHeight;
  	property = (u.vendorProperty(property).replace(/([A-Z]{1})/g, "-$1")).toLowerCase().replace(/^(webkit|ms)/, "-$1");
  	return window.getComputedStyle(node, null).getPropertyValue(property);
  }
  Util.hasFixedParent = u.hfp = function(node) {
  	while(node.nodeName.toLowerCase() != "body") {
  		if(u.gcs(node.parentNode, "position").match("fixed")) {
  			return true;
  		}
  		node = node.parentNode;
  	}
  	return false;
  }
  u.contains = function(scope, node) {
  	if(scope != node) {
  		if(scope.contains(node)) {
  			return true
  		}
  	}
  	return false;
  }
  u.containsOrIs = function(scope, node) {
  	if(scope == node || u.contains(scope, node)) {
  		return true
  	}
  	return false;
  }
  u.elementMatches = u.em = function(node, selector) {
  	return node.matches(selector);
  }
  Util.insertAfter = u.ia = function(after_node, insert_node) {
  	var next_node = u.ns(after_node);
  	if(next_node) {
  		after_node.parentNode.insertBefore(next_node, insert_node);
  	}
  	else {
  		after_node.parentNode.appendChild(insert_node);
  	}
  }
  Util.selectText = function(node) {
  	var selection = window.getSelection();
  	var range = document.createRange();
  	range.selectNodeContents(node);
  	selection.removeAllRanges();
  	selection.addRange(range);
  }
  Util.inNodeList = function(node, list) {
  	var i, list_node;
  	for(i = 0; i < list.length; i++) {
  		list_node = list[i]
  		if(list_node === node) {
  			return true;
  		}
  	}
  	return false;
  }
  
  
  /*u-events.js*/
  Util.Events = u.e = new function() {
  	this.event_pref = typeof(document.ontouchmove) == "undefined" || (navigator.maxTouchPoints > 1 && navigator.userAgent.match(/Windows/i)) ? "mouse" : "touch";
  	if (navigator.userAgent.match(/Windows/i) && ((obj(document.ontouchmove) && obj(document.onmousemove)) || (fun(document.ontouchmove) && fun(document.onmousemove)))) {
  		this.event_support = "multi";
  	}
  	else if (obj(document.ontouchmove) || fun(document.ontouchmove)) {
  		this.event_support = "touch";
  	}
  	else {
  		this.event_support = "mouse";
  	}
  	this.events = {
  		"mouse": {
  			"start":"mousedown",
  			"move":"mousemove",
  			"end":"mouseup",
  			"over":"mouseover",
  			"out":"mouseout"
  		},
  		"touch": {
  			"start":"touchstart",
  			"move":"touchmove",
  			"end":"touchend",
  			"over":"touchstart",
  			"out":"touchend"
  		}
  	}
  	this.kill = function(event) {
  		if(event) {
  			event.preventDefault();
  			event.stopPropagation();
  		}
  	}
  	this.addEvent = function(node, type, action) {
  		try {
  			node.addEventListener(type, action, false);
  		}
  		catch(exception) {
  			u.exception("u.e.addEvent", arguments, exception);
  		}
  	}
  	this.removeEvent = function(node, type, action) {
  		try {
  			node.removeEventListener(type, action, false);
  		}
  		catch(exception) {
  			u.exception("u.e.removeEvent", arguments, exception);
  		}
  	}
  	this.addStartEvent = this.addDownEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.addEvent(node, this.events.mouse.start, action);
  			u.e.addEvent(node, this.events.touch.start, action);
  		}
  		else {
  			u.e.addEvent(node, this.events[this.event_support].start, action);
  		}
  	}
  	this.removeStartEvent = this.removeDownEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.removeEvent(node, this.events.mouse.start, action);
  			u.e.removeEvent(node, this.events.touch.start, action);
  		}
  		else {
  			u.e.removeEvent(node, this.events[this.event_support].start, action);
  		}
  	}
  	this.addMoveEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.addEvent(node, this.events.mouse.move, action);
  			u.e.addEvent(node, this.events.touch.move, action);
  		}
  		else {
  			u.e.addEvent(node, this.events[this.event_support].move, action);
  		}
  	}
  	this.removeMoveEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.removeEvent(node, this.events.mouse.move, action);
  			u.e.removeEvent(node, this.events.touch.move, action);
  		}
  		else {
  			u.e.removeEvent(node, this.events[this.event_support].move, action);
  		}
  	}
  	this.addEndEvent = this.addUpEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.addEvent(node, this.events.mouse.end, action);
  			u.e.addEvent(node, this.events.touch.end, action);
  		}
  		else {
  			u.e.addEvent(node, this.events[this.event_support].end, action);
  		}
  	}
  	this.removeEndEvent = this.removeUpEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.removeEvent(node, this.events.mouse.end, action);
  			u.e.removeEvent(node, this.events.touch.end, action);
  		}
  		else {
  			u.e.removeEvent(node, this.events[this.event_support].end, action);
  		}
  	}
  	this.addOverEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.addEvent(node, this.events.mouse.over, action);
  			u.e.addEvent(node, this.events.touch.over, action);
  		}
  		else {
  			u.e.addEvent(node, this.events[this.event_support].over, action);
  		}
  	}
  	this.removeOverEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.removeEvent(node, this.events.mouse.over, action);
  			u.e.removeEvent(node, this.events.touch.over, action);
  		}
  		else {
  			u.e.removeEvent(node, this.events[this.event_support].over, action);
  		}
  	}
  	this.addOutEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.addEvent(node, this.events.mouse.out, action);
  			u.e.addEvent(node, this.events.touch.out, action);
  		}
  		else {
  			u.e.addEvent(node, this.events[this.event_support].out, action);
  		}
  	}
  	this.removeOutEvent = function(node, action) {
  		if(this.event_support == "multi") {
  			u.e.removeEvent(node, this.events.mouse.out, action);
  			u.e.removeEvent(node, this.events.touch.out, action);
  		}
  		else {
  			u.e.removeEvent(node, this.events[this.event_support].out, action);
  		}
  	}
  	this.resetClickEvents = function(node) {
  		u.t.resetTimer(node.t_held);
  		u.t.resetTimer(node.t_clicked);
  		this.removeEvent(node, "mouseup", this._dblclicked);
  		this.removeEvent(node, "touchend", this._dblclicked);
  		this.removeEvent(node, "mouseup", this._rightclicked);
  		this.removeEvent(node, "touchend", this._rightclicked);
  		this.removeEvent(node, "mousemove", this._cancelClick);
  		this.removeEvent(node, "touchmove", this._cancelClick);
  		this.removeEvent(node, "mouseout", this._cancelClick);
  		this.removeEvent(node, "mousemove", this._move);
  		this.removeEvent(node, "touchmove", this._move);
  	}
  	this.resetEvents = function(node) {
  		this.resetClickEvents(node);
  		if(fun(this.resetDragEvents)) {
  			this.resetDragEvents(node);
  		}
  	}
  	this.resetNestedEvents = function(node) {
  		while(node && node.nodeName != "HTML") {
  			this.resetEvents(node);
  			node = node.parentNode;
  		}
  	}
  	this._inputStart = function(event) {
  		this.event_var = event;
  		this.input_timestamp = event.timeStamp;
  		this.start_event_x = u.eventX(event);
  		this.start_event_y = u.eventY(event);
  		this.current_xps = 0;
  		this.current_yps = 0;
  		this.move_timestamp = event.timeStamp;
  		this.move_last_x = 0;
  		this.move_last_y = 0;
  		this.swiped = false;
  		if(!event.button) {
  			if(this.e_click || this.e_dblclick || this.e_hold) {
  				if(event.type.match(/mouse/)) {
  					var node = this;
  					while(node) {
  						if(node.e_drag || node.e_swipe) {
  							u.e.addMoveEvent(this, u.e._cancelClick);
  							break;
  						}
  						else {
  							node = node.parentNode;
  						}
  					}
  					u.e.addEvent(this, "mouseout", u.e._cancelClick);
  				}
  				else {
  					u.e.addMoveEvent(this, u.e._cancelClick);
  				}
  				u.e.addMoveEvent(this, u.e._move);
  				u.e.addEndEvent(this, u.e._dblclicked);
  				if(this.e_hold) {
  					this.t_held = u.t.setTimer(this, u.e._held, 750);
  				}
  			}
  			if(this.e_drag || this.e_swipe) {
  				u.e.addMoveEvent(this, u.e._pick);
  				u.e.addEndEvent(this, u.e._cancelPick);
  			}
  			if(this.e_scroll) {
  				u.e.addMoveEvent(this, u.e._scrollStart);
  				u.e.addEndEvent(this, u.e._scrollEnd);
  			}
  		}
  		else if(event.button === 2) {
  			if(this.e_rightclick) {
  				if(event.type.match(/mouse/)) {
  					u.e.addEvent(this, "mouseout", u.e._cancelClick);
  				}
  				else {
  					u.e.addMoveEvent(this, u.e._cancelClick);
  				}
  				u.e.addMoveEvent(this, u.e._move);
  				u.e.addEndEvent(this, u.e._rightclicked);
  			}
  		}
  		if(fun(this.inputStarted)) {
  			this.inputStarted(event);
  		}
  	}
  	this._cancelClick = function(event) {
  		var offset_x = u.eventX(event) - this.start_event_x;
  		var offset_y = u.eventY(event) - this.start_event_y;
  		if(event.type.match(/mouseout/) || (event.type.match(/move/) && (Math.abs(offset_x) > 15 || Math.abs(offset_y) > 15))) {
  			u.e.resetClickEvents(this);
  			if(fun(this.clickCancelled)) {
  				this.clickCancelled(event);
  			}
  		}
  	}
  	this._move = function(event) {
  		if(fun(this.moved)) {
  			this.current_x = u.eventX(event) - this.start_event_x;
  			this.current_y = u.eventY(event) - this.start_event_y;
  			this.current_xps = Math.round(((this.current_x - this.move_last_x) / (event.timeStamp - this.move_timestamp)) * 1000);
  			this.current_yps = Math.round(((this.current_y - this.move_last_y) / (event.timeStamp - this.move_timestamp)) * 1000);
  			this.move_timestamp = event.timeStamp;
  			this.move_last_x = this.current_x;
  			this.move_last_y = this.current_y;
  			this.moved(event);
  		}
  	}
  	this.hold = function(node, _options) {
  		node.e_hold_options = _options ? _options : {};
  		node.e_hold_options.eventAction = u.stringOr(node.e_hold_options.eventAction, "Held");
  		node.e_hold = true;
  		u.e.addStartEvent(node, this._inputStart);
  	}
  	this._held = function(event) {
  		this.e_hold_options.event = event;
  		u.stats.event(this, this.e_hold_options);
  		u.e.resetNestedEvents(this);
  		if(fun(this.held)) {
  			this.held(event);
  		}
  	}
  	this.click = this.tap = function(node, _options) {
  		node.e_click_options = _options ? _options : {};
  		node.e_click_options.eventAction = u.stringOr(node.e_click_options.eventAction, "Clicked");
  		node.e_click = true;
  		u.e.addStartEvent(node, this._inputStart);
  	}
  	this._clicked = function(event) {
  		if(this.e_click_options) {
  			this.e_click_options.event = event;
  			u.stats.event(this, this.e_click_options);
  		}
  		u.e.resetNestedEvents(this);
  		if(fun(this.clicked)) {
  			this.clicked(event);
  		}
  	}
  	this.rightclick = function(node, _options) {
  		node.e_rightclick_options = _options ? _options : {};
  		node.e_rightclick_options.eventAction = u.stringOr(node.e_rightclick_options.eventAction, "RightClicked");
  		node.e_rightclick = true;
  		u.e.addStartEvent(node, this._inputStart);
  		u.e.addEvent(node, "contextmenu", function(event){u.e.kill(event);});
  	}
  	this._rightclicked = function(event) {
  		u.bug("_rightclicked:", this);
  		if(this.e_rightclick_options) {
  			this.e_rightclick_options.event = event;
  			u.stats.event(this, this.e_rightclick_options);
  		}
  		u.e.resetNestedEvents(this);
  		if(fun(this.rightclicked)) {
  			this.rightclicked(event);
  		}
  	}
  	this.dblclick = this.doubleclick = this.doubletap = this.dbltap = function(node, _options) {
  		node.e_dblclick_options = _options ? _options : {};
  		node.e_dblclick_options.eventAction = u.stringOr(node.e_dblclick_options.eventAction, "DblClicked");
  		node.e_dblclick = true;
  		u.e.addStartEvent(node, this._inputStart);
  	}
  	this._dblclicked = function(event) {
  		if(u.t.valid(this.t_clicked) && event) {
  			this.e_dblclick_options.event = event;
  			u.stats.event(this, this.e_dblclick_options);
  			u.e.resetNestedEvents(this);
  			if(fun(this.dblclicked)) {
  				this.dblclicked(event);
  			}
  			return;
  		}
  		else if(!this.e_dblclick) {
  			this._clicked = u.e._clicked;
  			this._clicked(event);
  		}
  		else if(event.type == "timeout") {
  			this._clicked = u.e._clicked;
  			this._clicked(this.event_var);
  		}
  		else {
  			u.e.resetNestedEvents(this);
  			this.t_clicked = u.t.setTimer(this, u.e._dblclicked, 400);
  		}
  	}
  	this.hover = function(node, _options) {
  		node._hover_out_delay = 100;
  		node._hover_over_delay = 0;
  		node._callback_out = "out";
  		node._callback_over = "over";
  		if(obj(_options)) {
  			var argument;
  			for(argument in _options) {
  				switch(argument) {
  					case "over"				: node._callback_over		= _options[argument]; break;
  					case "out"				: node._callback_out		= _options[argument]; break;
  					case "delay_over"		: node._hover_over_delay	= _options[argument]; break;
  					case "delay"			: node._hover_out_delay		= _options[argument]; break;
  				}
  			}
  		}
  		node.e_hover = true;
  		u.e.addOverEvent(node, this._over);
  		u.e.addOutEvent(node, this._out);
  	}
  	this._over = function(event) {
  		u.t.resetTimer(this.t_out);
  		if(!this._hover_over_delay) {
  			u.e.__over.call(this, event);
  		}
  		else if(!u.t.valid(this.t_over)) {
  			this.t_over = u.t.setTimer(this, u.e.__over, this._hover_over_delay, event);
  		}
  	}
  	this.__over = function(event) {
  		u.t.resetTimer(this.t_out);
  		if(!this.is_hovered) {
  			this.is_hovered = true;
  			u.e.removeOverEvent(this, u.e._over);
  			u.e.addOverEvent(this, u.e.__over);
  			if(fun(this[this._callback_over])) {
  				this[this._callback_over](event);
  			}
  		}
  	}
  	this._out = function(event) {
  		u.t.resetTimer(this.t_over);
  		u.t.resetTimer(this.t_out);
  		this.t_out = u.t.setTimer(this, u.e.__out, this._hover_out_delay, event);
  	}
  	this.__out = function(event) {
  		this.is_hovered = false;
  		u.e.removeOverEvent(this, u.e.__over);
  		u.e.addOverEvent(this, u.e._over);
  		if(fun(this[this._callback_out])) {
  			this[this._callback_out](event);
  		}
  	}
  }
  
  
  /*u-events-browser.js*/
  u.e.addDOMReadyEvent = function(action) {
  	if(document.readyState && document.addEventListener) {
  		if((document.readyState == "interactive" && !u.browser("ie")) || document.readyState == "complete" || document.readyState == "loaded") {
  			action();
  		}
  		else {
  			var id = u.randomString();
  			window["DOMReady_" + id] = action;
  			eval('window["_DOMReady_' + id + '"] = function() {window["DOMReady_'+id+'"](); u.e.removeEvent(document, "DOMContentLoaded", window["_DOMReady_' + id + '"])}');
  			u.e.addEvent(document, "DOMContentLoaded", window["_DOMReady_" + id]);
  		}
  	}
  	else {
  		u.e.addOnloadEvent(action);
  	}
  }
  u.e.addOnloadEvent = function(action) {
  	if(document.readyState && (document.readyState == "complete" || document.readyState == "loaded")) {
  		action();
  	}
  	else {
  		var id = u.randomString();
  		window["Onload_" + id] = action;
  		eval('window["_Onload_' + id + '"] = function() {window["Onload_'+id+'"](); u.e.removeEvent(window, "load", window["_Onload_' + id + '"])}');
  		u.e.addEvent(window, "load", window["_Onload_" + id]);
  	}
  }
  u.e.addWindowEvent = function(node, type, action) {
  	var id = u.randomString();
  	window["_OnWindowEvent_node_"+ id] = node;
  	if(fun(action)) {
  		eval('window["_OnWindowEvent_callback_' + id + '"] = function(event) {window["_OnWindowEvent_node_'+ id + '"]._OnWindowEvent_callback_'+id+' = '+action+'; window["_OnWindowEvent_node_'+ id + '"]._OnWindowEvent_callback_'+id+'(event);};');
  	} 
  	else {
  		eval('window["_OnWindowEvent_callback_' + id + '"] = function(event) {if(fun(window["_OnWindowEvent_node_'+ id + '"]["'+action+'"])) {window["_OnWindowEvent_node_'+id+'"]["'+action+'"](event);}};');
  	}
  	u.e.addEvent(window, type, window["_OnWindowEvent_callback_" + id]);
  	return id;
  }
  u.e.removeWindowEvent = function(node, type, id) {
  	u.e.removeEvent(window, type, window["_OnWindowEvent_callback_"+id]);
  	delete window["_OnWindowEvent_node_"+id];
  	delete window["_OnWindowEvent_callback_"+id];
  }
  u.e.addWindowStartEvent = function(node, action) {
  	var id = u.randomString();
  	window["_Onstart_node_"+ id] = node;
  	if(fun(action)) {
  		eval('window["_Onstart_callback_' + id + '"] = function(event) {window["_Onstart_node_'+ id + '"]._Onstart_callback_'+id+' = '+action+'; window["_Onstart_node_'+ id + '"]._Onstart_callback_'+id+'(event);};');
  	} 
  	else {
  		eval('window["_Onstart_callback_' + id + '"] = function(event) {if(fun(window["_Onstart_node_'+ id + '"]["'+action+'"])) {window["_Onstart_node_'+id+'"]["'+action+'"](event);}};');
  	}
  	u.e.addStartEvent(window, window["_Onstart_callback_" + id]);
  	return id;
  }
  u.e.removeWindowStartEvent = function(node, id) {
  	u.e.removeStartEvent(window, window["_Onstart_callback_"+id]);
  	delete window["_Onstart_node_"+id]["_Onstart_callback_"+id];
  	delete window["_Onstart_node_"+id];
  	delete window["_Onstart_callback_"+id];
  }
  u.e.addWindowMoveEvent = function(node, action) {
  	var id = u.randomString();
  	window["_Onmove_node_"+ id] = node;
  	if(fun(action)) {
  		eval('window["_Onmove_callback_' + id + '"] = function(event) {window["_Onmove_node_'+ id + '"]._Onmove_callback_'+id+' = '+action+'; window["_Onmove_node_'+ id + '"]._Onmove_callback_'+id+'(event);};');
  	} 
  	else {
  		eval('window["_Onmove_callback_' + id + '"] = function(event) {if(fun(window["_Onmove_node_'+ id + '"]["'+action+'"])) {window["_Onmove_node_'+id+'"]["'+action+'"](event);}};');
  	}
  	u.e.addMoveEvent(window, window["_Onmove_callback_" + id]);
  	return id;
  }
  u.e.removeWindowMoveEvent = function(node, id) {
  	u.e.removeMoveEvent(window, window["_Onmove_callback_" + id]);
  	delete window["_Onmove_node_"+ id]["_Onmove_callback_"+id];
  	delete window["_Onmove_node_"+ id];
  	delete window["_Onmove_callback_"+ id];
  }
  u.e.addWindowEndEvent = function(node, action) {
  	var id = u.randomString();
  	window["_Onend_node_"+ id] = node;
  	if(fun(action)) {
  		eval('window["_Onend_callback_' + id + '"] = function(event) {window["_Onend_node_'+ id + '"]._Onend_callback_'+id+' = '+action+'; window["_Onend_node_'+ id + '"]._Onend_callback_'+id+'(event);};');
  	} 
  	else {
  		eval('window["_Onend_callback_' + id + '"] = function(event) {if(fun(window["_Onend_node_'+ id + '"]["'+action+'"])) {window["_Onend_node_'+id+'"]["'+action+'"](event);}};');
  	}
  	u.e.addEndEvent(window, window["_Onend_callback_" + id]);
  	return id;
  }
  u.e.removeWindowEndEvent = function(node, id) {
  	u.e.removeEndEvent(window, window["_Onend_callback_" + id]);
  	delete window["_Onend_node_"+ id]["_Onend_callback_"+id];
  	delete window["_Onend_node_"+ id];
  	delete window["_Onend_callback_"+ id];
  }
  
  
  /*u-geometry.js*/
  Util.absoluteX = u.absX = function(node) {
  	if(node.offsetParent) {
  		return node.offsetLeft + u.absX(node.offsetParent);
  	}
  	return node.offsetLeft;
  }
  Util.absoluteY = u.absY = function(node) {
  	if(node.offsetParent) {
  		return node.offsetTop + u.absY(node.offsetParent);
  	}
  	return node.offsetTop;
  }
  Util.relativeX = u.relX = function(node) {
  	if(u.gcs(node, "position").match(/absolute/) == null && node.offsetParent && u.gcs(node.offsetParent, "position").match(/relative|absolute|fixed/) == null) {
  		return node.offsetLeft + u.relX(node.offsetParent);
  	}
  	return node.offsetLeft;
  }
  Util.relativeY = u.relY = function(node) {
  	if(u.gcs(node, "position").match(/absolute/) == null && node.offsetParent && u.gcs(node.offsetParent, "position").match(/relative|absolute|fixed/) == null) {
  		return node.offsetTop + u.relY(node.offsetParent);
  	}
  	return node.offsetTop;
  }
  Util.actualWidth = u.actualW = function(node) {
  	return parseInt(u.gcs(node, "width"));
  }
  Util.actualHeight = u.actualH = function(node) {
  	return parseInt(u.gcs(node, "height"));
  }
  Util.eventX = function(event){
  	return (event.targetTouches && event.targetTouches.length ? event.targetTouches[0].pageX : event.pageX);
  }
  Util.eventY = function(event){
  	return (event.targetTouches && event.targetTouches.length ? event.targetTouches[0].pageY : event.pageY);
  }
  Util.browserWidth = u.browserW = function() {
  	return document.documentElement.clientWidth;
  }
  Util.browserHeight = u.browserH = function() {
  	return document.documentElement.clientHeight;
  }
  Util.htmlWidth = u.htmlW = function() {
  	return document.body.offsetWidth + parseInt(u.gcs(document.body, "margin-left")) + parseInt(u.gcs(document.body, "margin-right"));
  }
  Util.htmlHeight = u.htmlH = function() {
  	return document.body.offsetHeight + parseInt(u.gcs(document.body, "margin-top")) + parseInt(u.gcs(document.body, "margin-bottom"));
  }
  Util.pageScrollX = u.scrollX = function() {
  	return window.pageXOffset;
  }
  Util.pageScrollY = u.scrollY = function() {
  	return window.pageYOffset;
  }
  
  
  /*u-init.js*/
  Util.Modules = u.m = new Object();
  Util.init = function(scope) {
  	var i, node, nodes, module;
  	scope = scope && scope.nodeName ? scope : document;
  	nodes = u.ges("i\:([_a-zA-Z0-9])+", scope);
  	for(i = 0; i < nodes.length; i++) {
  		node = nodes[i];
  		while((module = u.cv(node, "i"))) {
  			u.rc(node, "i:"+module);
  			if(module && obj(u.m[module])) {
  				u.m[module].init(node);
  			}
  		}
  	}
  }
  
  
  /*u-math.js*/
  Util.random = function(min, max) {
  	return Math.round((Math.random() * (max - min)) + min);
  }
  Util.numToHex = function(num) {
  	return num.toString(16);
  }
  Util.hexToNum = function(hex) {
  	return parseInt(hex,16);
  }
  Util.round = function(number, decimals) {
  	var round_number = number*Math.pow(10, decimals);
  	return Math.round(round_number)/Math.pow(10, decimals);
  }
  
  /*u-string.js*/
  Util.cutString = function(string, length) {
  	var matches, match, i;
  	if(string.length <= length) {
  		return string;
  	}
  	else {
  		length = length-3;
  	}
  	matches = string.match(/\&[\w\d]+\;/g);
  	if(matches) {
  		for(i = 0; i < matches.length; i++){
  			match = matches[i];
  			if(string.indexOf(match) < length){
  				length += match.length-1;
  			}
  		}
  	}
  	return string.substring(0, length) + (string.length > length ? "..." : "");
  }
  Util.prefix = function(string, length, prefix) {
  	string = string.toString();
  	prefix = prefix ? prefix : "0";
  	while(string.length < length) {
  		string = prefix + string;
  	}
  	return string;
  }
  Util.randomString = function(length) {
  	var key = "", i;
  	length = length ? length : 8;
  	var pattern = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".split('');
  	for(i = 0; i < length; i++) {
  		key += pattern[u.random(0,35)];
  	}
  	return key;
  }
  Util.uuid = function() {
  	var chars = '0123456789abcdef'.split('');
  	var uuid = [], rnd = Math.random, r, i;
  	uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
  	uuid[14] = '4';
  	for(i = 0; i < 36; i++) {
  		if(!uuid[i]) {
  			r = 0 | rnd()*16;
  			uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r & 0xf];
  		}
   	}
  	return uuid.join('');
  }
  Util.stringOr = u.eitherOr = function(value, replacement) {
  	if(value !== undefined && value !== null) {
  		return value;
  	}
  	else {
  		return replacement ? replacement : "";
  	}	
  }
  Util.getMatches = function(string, regex) {
  	var match, matches = [];
  	while(match = regex.exec(string)) {
  		matches.push(match[1]);
  	}
  	return matches;
  }
  Util.upperCaseFirst = u.ucfirst = function(string) {
  	return string.replace(/^(.){1}/, function($1) {return $1.toUpperCase()});
  }
  Util.lowerCaseFirst = u.lcfirst = function(string) {
  	return string.replace(/^(.){1}/, function($1) {return $1.toLowerCase()});
  }
  Util.normalize = function(string) {
  	var table = {
  		'À':'A',  'à':'a',
  		'Á':'A',  'á':'a',
  		'Â':'A',  'â':'a',
  		'Ã':'A',  'ã':'a',
  		'Ä':'A',  'ä':'a',
  		'Å':'Aa', 'å':'aa',
  		'Æ':'Ae', 'æ':'ae',
  		'Ç':'C',  'ç':'c',
  		'Č':'C',  'ć':'c',
  		'Ć':'C',  'č':'c',
  		'Đ':'D',  'đ':'d',  'ð':'d',
  		'È':'E',  'è':'e',
  		'É':'E',  'é':'e',
  		'Ê':'E',  'ê':'e',
  		'Ë':'E',  'ë':'e',
  		'Ģ':'G',  'ģ':'g',
  		'Ğ':'G',  'ğ':'g',
  		'Ì':'I',  'ì':'i',
  		'Í':'I',  'í':'i',
  		'Î':'I',  'î':'i',
  		'Ï':'I',  'ï':'i',
  		'Ī':'I',  'ī':'i',
  		'Ķ':'K',  'ķ':'k',
  		'Ļ':'L',  'ļ':'l',
  		'Ñ':'N',  'ñ':'n',
  		'Ņ':'N',  'ņ':'n',
  		'Ò':'O',  'ò':'o',
  		'Ó':'O',  'ó':'o',
  		'Ô':'O',  'ô':'o',
  		'Õ':'O',  'õ':'o',
  		'Ö':'O',  'ö':'o',
  		'Ō':'O',  'ō':'o',
  		'Ø':'Oe', 'ø':'oe',
  		'Ŕ':'R',  'ŕ':'r',
  		'Š':'S',  'š':'s',
  		'Ş':'S',  'ş':'s',
  		'Ṩ':'S',  'ṩ':'s',
  		'Ù':'U',  'ù':'u',
  		'Ú':'U',  'ú':'u',
  		'Û':'U',  'û':'u',
  		'Ü':'U',  'ü':'u',
  		'Ū':'U',  'ū':'u',
  		'Ų':'U',  'ų':'u',
  		'Ŭ':'U',  'ŭ':'u',
  		'Ý':'Y',  'ý':'y',
  		'Ÿ':'Y',  'ÿ':'y',
  		'Ž':'Z',  'ž':'z',
  		'Þ':'B',  'þ':'b',
  		'ß':'Ss',
  		'@':' at ',
  		'&':'and',
  		'%':' percent',
  		'\\$':'USD',
  		'¥':'JPY',
  		'€':'EUR',
  		'£':'GBP',
  		'™':'trademark',
  		'©':'copyright',
  		'§':'s',
  		'\\*':'x',
  		'×':'x'
  	}
  	var char, regex;
  	for(char in table) {
  		regex = new RegExp(char, "g");
  		string = string.replace(regex, table[char]);
  	}
  	return string;
  }
  Util.superNormalize = function(string) {
  	string = u.normalize(string);
  	string = string.toLowerCase();
  	string = u.stripTags(string);
  	string = string.replace(/[^a-z0-9\_]/g, '-');
  	string = string.replace(/-+/g, '-');
  	string = string.replace(/^-|-$/g, '');
  	return string;
  }
  Util.stripTags = function(string) {
  	var node = document.createElement("div");
  	node.innerHTML = string;
  	return u.text(node);
  }
  Util.pluralize = function(count, singular, plural) {
  	if(count != 1) {
  		return count + " " + plural;
  	}
  	return count + " " + singular;
  }
  Util.isStringJSON = function(string) {
  	if(string.trim().substr(0, 1).match(/[\{\[]/i) && string.trim().substr(-1, 1).match(/[\}\]]/i)) {
  		try {
  			var test = JSON.parse(string);
  			if(obj(test)) {
  				test.isJSON = true;
  				return test;
  			}
  		}
  		catch(exception) {
  			console.log(exception)
  		}
  	}
  	return false;
  }
  Util.isStringHTML = function(string) {
  	if(string.trim().substr(0, 1).match(/[\<]/i) && string.trim().substr(-1, 1).match(/[\>]/i)) {
  		try {
  			var test = document.createElement("div");
  			test.innerHTML = string;
  			if(test.childNodes.length) {
  				var body_class = string.match(/<body class="([a-z0-9A-Z_: ]+)"/);
  				test.body_class = body_class ? body_class[1] : "";
  				var head_title = string.match(/<title>([^$]+)<\/title>/);
  				test.head_title = head_title ? head_title[1] : "";
  				test.isHTML = true;
  				return test;
  			}
  		}
  		catch(exception) {}
  	}
  	return false;
  }
  
  
  /*u-system.js*/
  Util.browser = function(model, version) {
  	var current_version = false;
  	if(model.match(/\bedge\b/i)) {
  		if(navigator.userAgent.match(/Windows[^$]+Gecko[^$]+Edge\/(\d+.\d)/i)) {
  			current_version = navigator.userAgent.match(/Edge\/(\d+)/i)[1];
  		}
  	}
  	if(model.match(/\bexplorer\b|\bie\b/i)) {
  		if(window.ActiveXObject && navigator.userAgent.match(/MSIE (\d+.\d)/i)) {
  			current_version = navigator.userAgent.match(/MSIE (\d+.\d)/i)[1];
  		}
  		else if(navigator.userAgent.match(/Trident\/[\d+]\.\d[^$]+rv:(\d+.\d)/i)) {
  			current_version = navigator.userAgent.match(/Trident\/[\d+]\.\d[^$]+rv:(\d+.\d)/i)[1];
  		}
  	}
  	if(model.match(/\bfirefox\b|\bgecko\b/i) && !u.browser("ie,edge")) {
  		if(navigator.userAgent.match(/Firefox\/(\d+\.\d+)/i)) {
  			current_version = navigator.userAgent.match(/Firefox\/(\d+\.\d+)/i)[1];
  		}
  	}
  	if(model.match(/\bwebkit\b/i)) {
  		if(navigator.userAgent.match(/WebKit/i) && !u.browser("ie,edge")) {
  			current_version = navigator.userAgent.match(/AppleWebKit\/(\d+.\d)/i)[1];
  		}
  	}
  	if(model.match(/\bchrome\b/i)) {
  		if(window.chrome && !u.browser("ie,edge")) {
  			current_version = navigator.userAgent.match(/Chrome\/(\d+)(.\d)/i)[1];
  		}
  	}
  	if(model.match(/\bsafari\b/i)) {
  		u.bug(navigator.userAgent);
  		if(!window.chrome && navigator.userAgent.match(/WebKit[^$]+Version\/(\d+)(.\d)/i) && !u.browser("ie,edge")) {
  			current_version = navigator.userAgent.match(/Version\/(\d+)(.\d)/i)[1];
  		}
  	}
  	if(model.match(/\bopera\b/i)) {
  		if(window.opera) {
  			if(navigator.userAgent.match(/Version\//)) {
  				current_version = navigator.userAgent.match(/Version\/(\d+)(.\d)/i)[1];
  			}
  			else {
  				current_version = navigator.userAgent.match(/Opera[\/ ]{1}(\d+)(.\d)/i)[1];
  			}
  		}
  	}
  	if(current_version) {
  		if(!version) {
  			return current_version;
  		}
  		else {
  			if(!isNaN(version)) {
  				return current_version == version;
  			}
  			else {
  				return eval(current_version + version);
  			}
  		}
  	}
  	else {
  		return false;
  	}
  }
  Util.segment = function(segment) {
  	if(!u.current_segment) {
  		var scripts = document.getElementsByTagName("script");
  		var script, i, src;
  		for(i = 0; i < scripts.length; i++) {
  			script = scripts[i];
  			seg_src = script.src.match(/\/seg_([a-z_]+)/);
  			if(seg_src) {
  				u.current_segment = seg_src[1];
  			}
  		}
  	}
  	if(segment) {
  		return segment == u.current_segment;
  	}
  	return u.current_segment;
  }
  Util.system = function(os, version) {
  	var current_version = false;
  	if(os.match(/\bwindows\b/i)) {
  		if(navigator.userAgent.match(/(Windows NT )(\d+.\d)/i)) {
  			current_version = navigator.userAgent.match(/(Windows NT )(\d+.\d)/i)[2];
  		}
  	}
  	else if(os.match(/\bmac\b/i)) {
  		if(navigator.userAgent.match(/(Macintosh; Intel Mac OS X )(\d+[._]{1}\d)/i)) {
  			current_version = navigator.userAgent.match(/(Macintosh; Intel Mac OS X )(\d+[._]{1}\d)/i)[2].replace("_", ".");
  		}
  	}
  	else if(os.match(/\blinux\b/i)) {
  		if(navigator.userAgent.match(/linux|x11/i) && !navigator.userAgent.match(/android/i)) {
  			current_version = true;
  		}
  	}
  	else if(os.match(/\bios\b/i)) {
  		if(navigator.userAgent.match(/(OS )(\d+[._]{1}\d+[._\d]*)( like Mac OS X)/i)) {
  			current_version = navigator.userAgent.match(/(OS )(\d+[._]{1}\d+[._\d]*)( like Mac OS X)/i)[2].replace(/_/g, ".");
  		}
  	}
  	else if(os.match(/\bandroid\b/i)) {
  		if(navigator.userAgent.match(/Android[ ._]?(\d+.\d)/i)) {
  			current_version = navigator.userAgent.match(/Android[ ._]?(\d+.\d)/i)[1];
  		}
  	}
  	else if(os.match(/\bwinphone\b/i)) {
  		if(navigator.userAgent.match(/Windows[ ._]?Phone[ ._]?(\d+.\d)/i)) {
  			current_version = navigator.userAgent.match(/Windows[ ._]?Phone[ ._]?(\d+.\d)/i)[1];
  		}
  	}
  	if(current_version) {
  		if(!version) {
  			return current_version;
  		}
  		else {
  			if(!isNaN(version)) {
  				return current_version == version;
  			}
  			else {
  				return eval(current_version + version);
  			}
  		}
  	}
  	else {
  		return false;
  	}
  }
  Util.support = function(property) {
  	if(document.documentElement) {
  		var style_property = u.lcfirst(property.replace(/^(-(moz|webkit|ms|o)-|(Moz|webkit|Webkit|ms|O))/, "").replace(/(-\w)/g, function(word){return word.replace(/-/, "").toUpperCase()}));
  		if(style_property in document.documentElement.style) {
  			return true;
  		}
  		else if(u.vendorPrefix() && (u.vendorPrefix()+u.ucfirst(style_property)) in document.documentElement.style) {
  			return true;
  		}
  	}
  	return false;
  }
  Util.vendor_properties = {};
  Util.vendorProperty = function(property) {
  	if(!Util.vendor_properties[property]) {
  		Util.vendor_properties[property] = property.replace(/(-\w)/g, function(word){return word.replace(/-/, "").toUpperCase()});
  		if(document.documentElement) {
  			var style_property = u.lcfirst(property.replace(/^(-(moz|webkit|ms|o)-|(Moz|webkit|Webkit|ms|O))/, "").replace(/(-\w)/g, function(word){return word.replace(/-/, "").toUpperCase()}));
  			if(style_property in document.documentElement.style) {
  				Util.vendor_properties[property] = style_property;
  			}
  			else if(u.vendorPrefix() && (u.vendorPrefix()+u.ucfirst(style_property)) in document.documentElement.style) {
  				Util.vendor_properties[property] = u.vendorPrefix()+u.ucfirst(style_property);
  			}
  		}
  	}
  	return Util.vendor_properties[property];
  }
  Util.vendor_prefix = false;
  Util.vendorPrefix = function() {
  	if(Util.vendor_prefix === false) {
  		Util.vendor_prefix = "";
  		if(document.documentElement && fun(window.getComputedStyle)) {
  			var styles = window.getComputedStyle(document.documentElement, "");
  			if(styles.length) {
  				var i, style, match;
  				for(i = 0; i < styles.length; i++) {
  					style = styles[i];
  					match = style.match(/^-(moz|webkit|ms)-/);
  					if(match) {
  						Util.vendor_prefix = match[1];
  						if(Util.vendor_prefix == "moz") {
  							Util.vendor_prefix = "Moz";
  						}
  						break;
  					}
  				}
  			}
  			else {
  				var x, match;
  				for(x in styles) {
  					match = x.match(/^(Moz|webkit|ms|OLink)/);
  					if(match) {
  						Util.vendor_prefix = match[1];
  						if(Util.vendor_prefix === "OLink") {
  							Util.vendor_prefix = "O";
  						}
  						break;
  					}
  				}
  			}
  		}
  	}
  	return Util.vendor_prefix;
  }
  
  
  /*u-timer.js*/
  Util.Timer = u.t = new function() {
  	this._timers = new Array();
  	this.setTimer = function(node, action, timeout, param) {
  		var id = this._timers.length;
  		param = param ? param : {"target":node, "type":"timeout"};
  		this._timers[id] = {"_a":action, "_n":node, "_p":param, "_t":setTimeout("u.t._executeTimer("+id+")", timeout)};
  		return id;
  	}
  	this.resetTimer = function(id) {
  		if(this._timers[id]) {
  			clearTimeout(this._timers[id]._t);
  			this._timers[id] = false;
  		}
  	}
  	this._executeTimer = function(id) {
  		var timer = this._timers[id];
  		this._timers[id] = false;
  		var node = timer._n;
  		if(fun(timer._a)) {
  			node._timer_action = timer._a;
  			node._timer_action(timer._p);
  			node._timer_action = null;
  		}
  		else if(fun(node[timer._a])) {
  			node[timer._a](timer._p);
  		}
  	}
  	this.setInterval = function(node, action, interval, param) {
  		var id = this._timers.length;
  		param = param ? param : {"target":node, "type":"timeout"};
  		this._timers[id] = {"_a":action, "_n":node, "_p":param, "_i":setInterval("u.t._executeInterval("+id+")", interval)};
  		return id;
  	}
  	this.resetInterval = function(id) {
  		if(this._timers[id]) {
  			clearInterval(this._timers[id]._i);
  			this._timers[id] = false;
  		}
  	}
  	this._executeInterval = function(id) {
  		var node = this._timers[id]._n;
  		if(fun(this._timers[id]._a)) {
  			node._interval_action = this._timers[id]._a;
  			node._interval_action(this._timers[id]._p);
  			node._interval_action = null;
  		}
  		else if(fun(node[this._timers[id]._a])) {
  			node[this._timers[id]._a](this._timers[id]._p);
  		}
  	}
  	this.valid = function(id) {
  		return this._timers[id] ? true : false;
  	}
  	this.resetAllTimers = function() {
  		var i, t;
  		for(i = 0; i < this._timers.length; i++) {
  			if(this._timers[i] && this._timers[i]._t) {
  				this.resetTimer(i);
  			}
  		}
  	}
  	this.resetAllIntervals = function() {
  		var i, t;
  		for(i = 0; i < this._timers.length; i++) {
  			if(this._timers[i] && this._timers[i]._i) {
  				this.resetInterval(i);
  			}
  		}
  	}
  }
  
  
  /*u-txt.js*/
  u.txt = function(index) {
  	if(!u.translations) {
  	}
  	if(index == "assign") {
  		u.bug("USING RESERVED INDEX: assign");
  		return "";
  	}
  	if(u.txt[index]) {
  		return u.txt[index];
  	}
  	u.bug("MISSING TEXT: "+index);
  	return "";
  }
  u.txt["assign"] = function(obj) {
  	for(x in obj) {
  		u.txt[x] = obj[x];
  	}
  }
  
  
  /*u-array-desktop_light.js*/
  if(!Array.prototype.unshift || new Array(1,2).unshift(0) != 3) {
  	Array.prototype.unshift = function(a) {
  		var b;
  		this.reverse();
  		b = this.push(a);
  		this.reverse();
  		return b
  	};
  }
  if(!Array.prototype.shift) {
  	Array.prototype.shift = function() {
  		for(var i = 0, b = this[0], l = this.length-1; i < l; i++ ) {
  			this[i] = this[i+1];
  		}
  		this.length--;
  		return b;
  	};
  }
  if(!Array.prototype.indexOf) {
  	Array.prototype.indexOf = function (obj, start) {
  		for(var i = (start || 0); i < this.length; i++) {
  			if(this[i] == obj) {
  				return i;
  			}
  		}
  		return -1;
  	}
  }
  if(!Object.keys) {
  	Object.keys = function(object) {
  		var keys = [];
  		var x;
  		for(x in object) {
  			if(object.hasOwnProperty(x)) {
  				keys.push(x);
  			}
  		}
  		return keys;
  	};
  }
  
  /*u-dom-desktop_ie.js*/
  if(document.documentMode && document.documentMode <= 10 && document.documentMode >= 8) {
  	Util.appendElement = u.ae = function(_parent, node_type, attributes) {
  		try {
  			var node = (obj(node_type)) ? node_type : (node_type == "svg" ? document.createElementNS("http://www.w3.org/2000/svg", node_type) : document.createElement(node_type));
  			if(attributes) {
  				var attribute;
  				for(attribute in attributes) {
  					if(!attribute.match(/^(value|html)$/)) {
  						node.setAttribute(attribute, attributes[attribute]);
  					}
  				}
  			}
  			node = _parent.appendChild(node);
  			if(attributes) {
  				if(attributes["value"]) {
  					node.value = attributes["value"];
  				}
  				if(attributes["html"]) {
  					node.innerHTML = attributes["html"];
  				}
  			}
  			return node;
  		}
  		catch(exception) {
  			u.exception("u.ae (desktop_ie10)", arguments, exception);
  		}
  	}
  	Util.insertElement = u.ie = function(_parent, node_type, attributes) {
  		try {
  			var node = (obj(node_type)) ? node_type : (node_type == "svg" ? document.createElementNS("http://www.w3.org/2000/svg", node_type) : document.createElement(node_type));
  			if(attributes) {
  				var attribute;
  				for(attribute in attributes) {
  					if(!attribute.match(/^(value|html)$/)) {
  						node.setAttribute(attribute, attributes[attribute]);
  					}
  				}
  			}
  			node = _parent.insertBefore(node, _parent.firstChild);
  			if(attributes) {
  				if(attributes["value"]) {
  					node.value = attributes["value"];
  				}
  				if(attributes["html"]) {
  					node.innerHTML = attributes["html"];
  				}
  			}
  			return node;
  		}
  		catch(exception) {
  			u.exception("u.ie (desktop_ie10)", arguments, exception);
  		}
  	}
  }
  if(document.documentMode && document.documentMode <= 11 && document.documentMode >= 8) {
  	Util.hasClass = u.hc = function(node, classname) {
  		var regexp = new RegExp("(^|\\s)(" + classname + ")(\\s|$)");
  		if(node instanceof SVGElement) {
  			if(regexp.test(node.className.baseVal)) {
  				return true;
  			}
  		}
  		else {
  			if(regexp.test(node.className)) {
  				return true;
  			}
  		}
  		return false;
  	}
  	Util.addClass = u.ac = function(node, classname, dom_update) {
  		var regexp = new RegExp("(^|\\s)" + classname + "(\\s|$)");
  		if(node instanceof SVGElement) {
  			if(!regexp.test(node.className.baseVal)) {
  				node.className.baseVal += node.className.baseVal ? " " + classname : classname;
  			}
  		}
  		else {
  			if(!regexp.test(node.className)) {
  				node.className += node.className ? " " + classname : classname;
  			}
  		}
  		dom_update = (!dom_update) || (node.offsetTop);
  		return node.className;
  	}
  	Util.removeClass = u.rc = function(node, classname, dom_update) {
  		var regexp = new RegExp("(^|\\s)(" + classname + ")(?=[\\s]|$)", "g");
  		if(node instanceof SVGElement) {
  			node.className.baseVal = node.className.baseVal.replace(regexp, " ").trim().replace(/[\s]{2}/g, " ");
  		}
  		else {
  			node.className = node.className.replace(regexp, " ").trim().replace(/[\s]{2}/g, " ");
  		}
  		dom_update = (!dom_update) || (node.offsetTop);
  		return node.className;
  	}
  }
  
  
  /*u-dom-desktop_light.js*/
  Util.setClass = u.sc = function(node, classname, dom_update) {
  	var old_class;
  	if(typeof(SVGElement) !== "undefined" && node instanceof SVGElement) {
  		old_class = node.className.baseVal;
  		node.className.baseVal = classname;
  	}
  	else {
  		old_class = node.className;
  		node.className = classname;
  	}
  	dom_update = (!dom_update) || (node.offsetTop);
  	return old_class;
  }
  Util.hasClass = u.hc = function(node, classname) {
  	var regexp = new RegExp("(^|\\s)(" + classname + ")(\\s|$)");
  	if(typeof(SVGElement) !== "undefined" && node instanceof SVGElement) {
  		if(regexp.test(node.className.baseVal)) {
  			return true;
  		}
  	}
  	else {
  		if(regexp.test(node.className)) {
  			return true;
  		}
  	}
  	return false;
  }
  Util.addClass = u.ac = function(node, classname, dom_update) {
  	var regexp = new RegExp("(^|\\s)" + classname + "(\\s|$)");
  	if(typeof(SVGElement) !== "undefined" && node instanceof SVGElement) {
  		if(!regexp.test(node.className.baseVal)) {
  			node.className.baseVal += node.className.baseVal ? " " + classname : classname;
  		}
  	}
  	else {
  		if(!regexp.test(node.className)) {
  			node.className += node.className ? " " + classname : classname;
  		}
  	}
  	dom_update = (!dom_update) || (node.offsetTop);
  	return node.className;
  }
  Util.removeClass = u.rc = function(node, classname, dom_update) {
  	var regexp = new RegExp("(^|\\s)(" + classname + ")(?=[\\s]|$)", "g");
  	if(typeof(SVGElement) !== "undefined" && node instanceof SVGElement) {
  		node.className.baseVal = node.className.baseVal.replace(regexp, " ").trim().replace(/[\s]{2}/g, " ");
  	}
  	else {
  		node.className = node.className.replace(regexp, " ").trim().replace(/[\s]{2}/g, " ");
  	}
  	dom_update = (!dom_update) || (node.offsetTop);
  	return node.className;
  }
  if(typeof(document.defaultView) == "undefined") {
  	Util.getComputedStyle = u.gcs = function(e, attribute) {
  		e.offsetHeight;
  		if(attribute == "opacity" && e._opacity != undefined) {
  			return e._opacity;
  		}
  		// 
  		if(document.body.currentStyle && attribute != "opacity") {
  			attribute = attribute.replace(/(-\w)/g, function(word){return word.replace(/-/, "").toUpperCase()});
  			if(e.currentStyle[attribute] == "medium") {
  				return 0;
  			}
  			return e.currentStyle[attribute];
  		}
  		else if(document.body.currentStyle && attribute == "opacity" && e.currentStyle["filter"]) {
  			var match = e.currentStyle["filter"].match(/Opacity=([0-9]+)/);
  			if(match) {
  				return match[1]/100;
  			}
  		}
  		return false;
  	}
  }
  if(document.all && document.addEventListener == undefined) {
  	Util.appendElement = u.ae = function(_parent, node_type, attributes) {
  		try {
  			var node = (obj(node_type)) ? node_type : (node_type == "svg" && typeof(SVGElement) !== "undefined" ? document.createElementNS("http://www.w3.org/2000/svg", node_type) : document.createElement(node_type));
  			if(attributes) {
  				var attribute;
  				for(attribute in attributes) {
  					if(!attribute.match(/^(class|type|value|html|checked)$/)) {
  						node.setAttribute(attribute, attributes[attribute]);
  					}
  				}
  				if(attributes["class"]) {
  					u.setClass(node, attributes["class"]);
  				}
  				if(attributes["type"]) {
  					node.type = attributes["type"].replace(/email|date|datetime|number|tel/, "text");
  				}
  			}
  			node = _parent.appendChild(node);
  			if(attributes) {
  				if(attributes["value"]) {
  					node.value = attributes["value"];
  				}
  				if(attributes["checked"]) {
  					node.checked = attributes["checked"];
  				}
  				if(attributes["html"]) {
  					node.innerHTML = attributes["html"];
  					if(attributes["html"].match(/(src|href)\=\"\{/i)) {
  						var nodes, matches, n, i;
  						matches = u.getMatches(attributes["html"], new RegExp("src\=\"([^\"]+)\"", "ig") );
  						nodes = u.qsa("[src]", node);
  						for(i = 0; i < nodes.length; i++) {
  							n = nodes[i];
  							n.src = matches[i];
  						}
  						matches = u.getMatches(attributes["html"], new RegExp("href\=\"([^\"]+)\"", "ig") );
  						nodes = u.qsa("[href]", node);
  						for(i = 0; i < nodes; i++) {
  							n = nodes[i];
  							n.href = matches[i];
  						}
  					}
  				}
  			}
  			return node;
  		}
  		catch(exception) {
  			u.exception("u.ae (desktop_light)", arguments, exception);
  		}
  	}
  	Util.insertElement = u.ie = function(_parent, node_type, attributes) {
  		try {
  			var node = (obj(node_type)) ? node_type : (node_type == "svg" && typeof(SVGElement) !== "undefined" ? document.createElementNS("http://www.w3.org/2000/svg", node_type) : document.createElement(node_type));
  			if(attributes) {
  				var attribute;
  				for(attribute in attributes) {
  					if(!attribute.match(/^(class|type|value|html)$/)) {
  						node.setAttribute(attribute, attributes[attribute]);
  					}
  				}
  				if(attributes["class"]) {
  					u.setClass(node, attributes["class"]);
  				}
  				if(attributes["type"]) {
  					node.type = attributes["type"].replace(/email|date|datetime|number|tel/, "text");
  				}
  			}
  			node = _parent.insertBefore(node, _parent.firstChild);
  			if(attributes) {
  				if(attributes["value"]) {
  					node.value = attributes["value"];
  				}
  				if(attributes["checked"]) {
  					node.checked = attributes["checked"];
  				}
  				if(attributes["html"]) {
  					node.innerHTML = attributes["html"];
  					if(attributes["html"].match(/(src|href)\=\"\{/i)) {
  						var nodes, matches, n, i;
  						matches = u.getMatches(attributes["html"], new RegExp("src\=\"([^\"]+)\"", "ig") );
  						nodes = u.qsa("[src]", node);
  						for(i = 0; i < nodes.length; i++) {
  							n = nodes[i];
  							n.src = matches[i];
  						}
  						matches = u.getMatches(attributes["html"], new RegExp("href\=\"([^\"]+)\"", "ig") );
  						nodes = u.qsa("[href]", node);
  						for(i = 0; i < nodes.length; i++) {
  							n = nodes[i];
  							n.href = matches[i];
  						}
  					}
  				}
  			}
  			return node;
  		}
  		catch(exception) {
  			u.exception("u.ie (desktop_light)", arguments, exception);
  		}
  	}
  	Util.wrapElement = u.we = function(node, node_type, attributes) {
  		try {
  			var wrapper_node = node.parentNode.insertBefore(document.createElement(node_type), node);
  			if(attributes) {
  				var attribute;
  				for(attribute in attributes) {
  					if(attribute != "class") {
  						wrapper_node.setAttribute(attribute, attributes[attribute]);
  					}
  				}
  				if(attributes["class"]) {
  					u.setClass(wrapper_node, attributes["class"]);
  				}
  			}
  			wrapper_node.appendChild(node);
  			return wrapper_node;
  		}
  		catch(exception) {
  			u.exception("u.we (desktop_light)", arguments, exception);
  		}
  		return false;
  	}
  	Util.wrapContent = u.wc = function(node, node_type, attributes) {
  		try {
  			var wrapper_node = document.createElement(node_type);
  			if(attributes) {
  				var attribute;
  				for(attribute in attributes) {
  					if(attribute != "class") {
  						wrapper_node.setAttribute(attribute, attributes[attribute]);
  					}
  				}
  			}	
  			if(attributes["class"]) {
  				u.setClass(wrapper_node, attributes["class"]);
  			}
  			while(node.childNodes.length) {
  				wrapper_node.appendChild(node.childNodes[0]);
  			}
  			node.appendChild(wrapper_node);
  			return wrapper_node;
  		}
  		catch(exception) {
  			u.exception("u.wc (desktop_light)", arguments, exception);
  		}
  		return false;
  	}
  }
  if(typeof(document.textContent) == "undefined") {
  	Util.textContent = u.text = function(node) {
  		if(node.textContent) {
  			return node.textContent;
  		}
  		else if(node.innerText) {
  			return node.innerText;
  		}
  		else {
  			return node.innerHTML.replace(/\<[^\>]*\>/g, "");
  		}
  	}
  }
  if(typeof(document.contains) == "undefined") {
  	u.contains = function(scope, node) {
  		if(scope != node) {
  			while(node != null) {
  				if(node == scope) {
  					return true;
  				}
  				node = node.parentNode;
  			}
  		}
  		return false;
  	}
  }
  if(!Element.prototype.matches) {
  	Element.prototype.matches = Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector || function(selector) {
  		var matches = (this.parentNode || this.document || this.ownerDocument).querySelectorAll(selector);
  		return u.nodeInList(this, matches);
  	};
  }
  if(document.querySelector == undefined) {
  	(function(){
  	var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
  		expando = "sizcache" + (Math.random() + '').replace('.', ''),
  		done = 0,
  		toString = Object.prototype.toString,
  		hasDuplicate = false,
  		baseHasDuplicate = true,
  		rBackslash = /\\/g,
  		rReturn = /\r\n/g,
  		rNonWord = /\W/;
  	[0, 0].sort(function() {
  		baseHasDuplicate = false;
  		return 0;
  	});
  	var Sizzle = function( selector, context, results, seed ) {
  		results = results || [];
  		context = context || document;
  		var origContext = context;
  		if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
  			return [];
  		}
  		if ( !selector || typeof selector !== "string" ) {
  			return results;
  		}
  		var m, set, checkSet, extra, ret, cur, pop, i,
  			prune = true,
  			contextXML = Sizzle.isXML( context ),
  			parts = [],
  			soFar = selector;
  		do {
  			chunker.exec( "" );
  			m = chunker.exec( soFar );
  			if ( m ) {
  				soFar = m[3];
  				parts.push( m[1] );
  				if ( m[2] ) {
  					extra = m[3];
  					break;
  				}
  			}
  		} while ( m );
  		if ( parts.length > 1 && origPOS.exec( selector ) ) {
  			if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
  				set = posProcess( parts[0] + parts[1], context, seed );
  			} else {
  				set = Expr.relative[ parts[0] ] ?
  					[ context ] :
  					Sizzle( parts.shift(), context );
  				while ( parts.length ) {
  					selector = parts.shift();
  					if ( Expr.relative[ selector ] ) {
  						selector += parts.shift();
  					}
  					set = posProcess( selector, set, seed );
  				}
  			}
  		} else {
  			if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
  					Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
  				ret = Sizzle.find( parts.shift(), context, contextXML );
  				context = ret.expr ?
  					Sizzle.filter( ret.expr, ret.set )[0] :
  					ret.set[0];
  			}
  			if ( context ) {
  				ret = seed ?
  					{ expr: parts.pop(), set: makeArray(seed) } :
  					Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
  				set = ret.expr ?
  					Sizzle.filter( ret.expr, ret.set ) :
  					ret.set;
  				if ( parts.length > 0 ) {
  					checkSet = makeArray( set );
  				} else {
  					prune = false;
  				}
  				while ( parts.length ) {
  					cur = parts.pop();
  					pop = cur;
  					if ( !Expr.relative[ cur ] ) {
  						cur = "";
  					} else {
  						pop = parts.pop();
  					}
  					if ( pop == null ) {
  						pop = context;
  					}
  					Expr.relative[ cur ]( checkSet, pop, contextXML );
  				}
  			} else {
  				checkSet = parts = [];
  			}
  		}
  		if ( !checkSet ) {
  			checkSet = set;
  		}
  		if ( !checkSet ) {
  			Sizzle.error( cur || selector );
  		}
  		if ( toString.call(checkSet) === "[object Array]" ) {
  			if ( !prune ) {
  				results.push.apply( results, checkSet );
  			} else if ( context && context.nodeType === 1 ) {
  				for ( i = 0; checkSet[i] != null; i++ ) {
  					if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
  						results.push( set[i] );
  					}
  				}
  			} else {
  				for ( i = 0; checkSet[i] != null; i++ ) {
  					if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
  						results.push( set[i] );
  					}
  				}
  			}
  		} else {
  			makeArray( checkSet, results );
  		}
  		if ( extra ) {
  			Sizzle( extra, origContext, results, seed );
  			Sizzle.uniqueSort( results );
  		}
  		return results;
  	};
  	Sizzle.uniqueSort = function( results ) {
  		if ( sortOrder ) {
  			hasDuplicate = baseHasDuplicate;
  			results.sort( sortOrder );
  			if ( hasDuplicate ) {
  				for ( var i = 1; i < results.length; i++ ) {
  					if ( results[i] === results[ i - 1 ] ) {
  						results.splice( i--, 1 );
  					}
  				}
  			}
  		}
  		return results;
  	};
  	Sizzle.matches = function( expr, set ) {
  		return Sizzle( expr, null, null, set );
  	};
  	Sizzle.matchesSelector = function( node, expr ) {
  		return Sizzle( expr, null, null, [node] ).length > 0;
  	};
  	Sizzle.find = function( expr, context, isXML ) {
  		var set, i, len, match, type, left;
  		if ( !expr ) {
  			return [];
  		}
  		for ( i = 0, len = Expr.order.length; i < len; i++ ) {
  			type = Expr.order[i];
  			if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
  				left = match[1];
  				match.splice( 1, 1 );
  				if ( left.substr( left.length - 1 ) !== "\\" ) {
  					match[1] = (match[1] || "").replace( rBackslash, "" );
  					set = Expr.find[ type ]( match, context, isXML );
  					if ( set != null ) {
  						expr = expr.replace( Expr.match[ type ], "" );
  						break;
  					}
  				}
  			}
  		}
  		if ( !set ) {
  			set = typeof context.getElementsByTagName !== "undefined" ?
  				context.getElementsByTagName( "*" ) :
  				[];
  		}
  		return { set: set, expr: expr };
  	};
  	Sizzle.filter = function( expr, set, inplace, not ) {
  		var match, anyFound,
  			type, found, item, filter, left,
  			i, pass,
  			old = expr,
  			result = [],
  			curLoop = set,
  			isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
  		while ( expr && set.length ) {
  			for ( type in Expr.filter ) {
  				if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
  					filter = Expr.filter[ type ];
  					left = match[1];
  					anyFound = false;
  					match.splice(1,1);
  					if ( left.substr( left.length - 1 ) === "\\" ) {
  						continue;
  					}
  					if ( curLoop === result ) {
  						result = [];
  					}
  					if ( Expr.preFilter[ type ] ) {
  						match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
  						if ( !match ) {
  							anyFound = found = true;
  						} else if ( match === true ) {
  							continue;
  						}
  					}
  					if ( match ) {
  						for ( i = 0; (item = curLoop[i]) != null; i++ ) {
  							if ( item ) {
  								found = filter( item, match, i, curLoop );
  								pass = not ^ found;
  								if ( inplace && found != null ) {
  									if ( pass ) {
  										anyFound = true;
  									} else {
  										curLoop[i] = false;
  									}
  								} else if ( pass ) {
  									result.push( item );
  									anyFound = true;
  								}
  							}
  						}
  					}
  					if ( found !== undefined ) {
  						if ( !inplace ) {
  							curLoop = result;
  						}
  						expr = expr.replace( Expr.match[ type ], "" );
  						if ( !anyFound ) {
  							return [];
  						}
  						break;
  					}
  				}
  			}
  			if ( expr === old ) {
  				if ( anyFound == null ) {
  					Sizzle.error( expr );
  				} else {
  					break;
  				}
  			}
  			old = expr;
  		}
  		return curLoop;
  	};
  	Sizzle.error = function( msg ) {
  		throw new Error( "Syntax error, unrecognized expression: " + msg );
  	};
  	var getText = Sizzle.getText = function( elem ) {
  	    var i, node,
  			nodeType = elem.nodeType,
  			ret = "";
  		if ( nodeType ) {
  			if ( nodeType === 1 || nodeType === 9 ) {
  				if ( typeof elem.textContent === 'string' ) {
  					return elem.textContent;
  				} else if ( typeof elem.innerText === 'string' ) {
  					return elem.innerText.replace( rReturn, '' );
  				} else {
  					for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
  						ret += getText( elem );
  					}
  				}
  			} else if ( nodeType === 3 || nodeType === 4 ) {
  				return elem.nodeValue;
  			}
  		} else {
  			for ( i = 0; (node = elem[i]); i++ ) {
  				if ( node.nodeType !== 8 ) {
  					ret += getText( node );
  				}
  			}
  		}
  		return ret;
  	};
  	var Expr = Sizzle.selectors = {
  		order: [ "ID", "NAME", "TAG" ],
  		match: {
  			ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
  			CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
  			NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
  			ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
  			TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
  			CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
  			POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
  			PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
  		},
  		leftMatch: {},
  		attrMap: {
  			"class": "className",
  			"for": "htmlFor"
  		},
  		attrHandle: {
  			href: function( elem ) {
  				return elem.getAttribute( "href" );
  			},
  			type: function( elem ) {
  				return elem.getAttribute( "type" );
  			}
  		},
  		relative: {
  			"+": function(checkSet, part){
  				var isPartStr = str(part),
  					isTag = isPartStr && !rNonWord.test( part ),
  					isPartStrNotTag = isPartStr && !isTag;
  				if ( isTag ) {
  					part = part.toLowerCase();
  				}
  				for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
  					if ( (elem = checkSet[i]) ) {
  						while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
  						checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
  							elem || false :
  							elem === part;
  					}
  				}
  				if ( isPartStrNotTag ) {
  					Sizzle.filter( part, checkSet, true );
  				}
  			},
  			">": function( checkSet, part ) {
  				var elem,
  					isPartStr = str(part),
  					i = 0,
  					l = checkSet.length;
  				if ( isPartStr && !rNonWord.test( part ) ) {
  					part = part.toLowerCase();
  					for ( ; i < l; i++ ) {
  						elem = checkSet[i];
  						if ( elem ) {
  							var parent = elem.parentNode;
  							checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
  						}
  					}
  				} else {
  					for ( ; i < l; i++ ) {
  						elem = checkSet[i];
  						if ( elem ) {
  							checkSet[i] = isPartStr ?
  								elem.parentNode :
  								elem.parentNode === part;
  						}
  					}
  					if ( isPartStr ) {
  						Sizzle.filter( part, checkSet, true );
  					}
  				}
  			},
  			"": function(checkSet, part, isXML){
  				var nodeCheck,
  					doneName = done++,
  					checkFn = dirCheck;
  				if ( str(part) && !rNonWord.test( part ) ) {
  					part = part.toLowerCase();
  					nodeCheck = part;
  					checkFn = dirNodeCheck;
  				}
  				checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
  			},
  			"~": function( checkSet, part, isXML ) {
  				var nodeCheck,
  					doneName = done++,
  					checkFn = dirCheck;
  				if ( str(part) && !rNonWord.test( part ) ) {
  					part = part.toLowerCase();
  					nodeCheck = part;
  					checkFn = dirNodeCheck;
  				}
  				checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
  			}
  		},
  		find: {
  			ID: function( match, context, isXML ) {
  				if ( typeof context.getElementById !== "undefined" && !isXML ) {
  					var m = context.getElementById(match[1]);
  					return m && m.parentNode ? [m] : [];
  				}
  			},
  			NAME: function( match, context ) {
  				if ( typeof context.getElementsByName !== "undefined" ) {
  					var ret = [],
  						results = context.getElementsByName( match[1] );
  					for ( var i = 0, l = results.length; i < l; i++ ) {
  						if ( results[i].getAttribute("name") === match[1] ) {
  							ret.push( results[i] );
  						}
  					}
  					return ret.length === 0 ? null : ret;
  				}
  			},
  			TAG: function( match, context ) {
  				if ( typeof context.getElementsByTagName !== "undefined" ) {
  					return context.getElementsByTagName( match[1] );
  				}
  			}
  		},
  		preFilter: {
  			CLASS: function( match, curLoop, inplace, result, not, isXML ) {
  				match = " " + match[1].replace( rBackslash, "" ) + " ";
  				if ( isXML ) {
  					return match;
  				}
  				for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
  					if ( elem ) {
  						if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
  							if ( !inplace ) {
  								result.push( elem );
  							}
  						} else if ( inplace ) {
  							curLoop[i] = false;
  						}
  					}
  				}
  				return false;
  			},
  			ID: function( match ) {
  				return match[1].replace( rBackslash, "" );
  			},
  			TAG: function( match, curLoop ) {
  				return match[1].replace( rBackslash, "" ).toLowerCase();
  			},
  			CHILD: function( match ) {
  				if ( match[1] === "nth" ) {
  					if ( !match[2] ) {
  						Sizzle.error( match[0] );
  					}
  					match[2] = match[2].replace(/^\+|\s*/g, '');
  					var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
  						match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
  						!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
  					match[2] = (test[1] + (test[2] || 1)) - 0;
  					match[3] = test[3] - 0;
  				}
  				else if ( match[2] ) {
  					Sizzle.error( match[0] );
  				}
  				match[0] = done++;
  				return match;
  			},
  			ATTR: function( match, curLoop, inplace, result, not, isXML ) {
  				var name = match[1] = match[1].replace( rBackslash, "" );
  				if ( !isXML && Expr.attrMap[name] ) {
  					match[1] = Expr.attrMap[name];
  				}
  				match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
  				if ( match[2] === "~=" ) {
  					match[4] = " " + match[4] + " ";
  				}
  				return match;
  			},
  			PSEUDO: function( match, curLoop, inplace, result, not ) {
  				if ( match[1] === "not" ) {
  					if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
  						match[3] = Sizzle(match[3], null, null, curLoop);
  					} else {
  						var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
  						if ( !inplace ) {
  							result.push.apply( result, ret );
  						}
  						return false;
  					}
  				} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
  					return true;
  				}
  				return match;
  			},
  			POS: function( match ) {
  				match.unshift( true );
  				return match;
  			}
  		},
  		filters: {
  			enabled: function( elem ) {
  				return elem.disabled === false && elem.type !== "hidden";
  			},
  			disabled: function( elem ) {
  				return elem.disabled === true;
  			},
  			checked: function( elem ) {
  				return elem.checked === true;
  			},
  			selected: function( elem ) {
  				if ( elem.parentNode ) {
  					elem.parentNode.selectedIndex;
  				}
  				return elem.selected === true;
  			},
  			parent: function( elem ) {
  				return !!elem.firstChild;
  			},
  			empty: function( elem ) {
  				return !elem.firstChild;
  			},
  			has: function( elem, i, match ) {
  				return !!Sizzle( match[3], elem ).length;
  			},
  			header: function( elem ) {
  				return (/h\d/i).test( elem.nodeName );
  			},
  			text: function( elem ) {
  				var attr = elem.getAttribute( "type" ), type = elem.type;
  				return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
  			},
  			radio: function( elem ) {
  				return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
  			},
  			checkbox: function( elem ) {
  				return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
  			},
  			file: function( elem ) {
  				return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
  			},
  			password: function( elem ) {
  				return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
  			},
  			submit: function( elem ) {
  				var name = elem.nodeName.toLowerCase();
  				return (name === "input" || name === "button") && "submit" === elem.type;
  			},
  			image: function( elem ) {
  				return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
  			},
  			reset: function( elem ) {
  				var name = elem.nodeName.toLowerCase();
  				return (name === "input" || name === "button") && "reset" === elem.type;
  			},
  			button: function( elem ) {
  				var name = elem.nodeName.toLowerCase();
  				return name === "input" && "button" === elem.type || name === "button";
  			},
  			input: function( elem ) {
  				return (/input|select|textarea|button/i).test( elem.nodeName );
  			},
  			focus: function( elem ) {
  				return elem === elem.ownerDocument.activeElement;
  			}
  		},
  		setFilters: {
  			first: function( elem, i ) {
  				return i === 0;
  			},
  			last: function( elem, i, match, array ) {
  				return i === array.length - 1;
  			},
  			even: function( elem, i ) {
  				return i % 2 === 0;
  			},
  			odd: function( elem, i ) {
  				return i % 2 === 1;
  			},
  			lt: function( elem, i, match ) {
  				return i < match[3] - 0;
  			},
  			gt: function( elem, i, match ) {
  				return i > match[3] - 0;
  			},
  			nth: function( elem, i, match ) {
  				return match[3] - 0 === i;
  			},
  			eq: function( elem, i, match ) {
  				return match[3] - 0 === i;
  			}
  		},
  		filter: {
  			PSEUDO: function( elem, match, i, array ) {
  				var name = match[1],
  					filter = Expr.filters[ name ];
  				if ( filter ) {
  					return filter( elem, i, match, array );
  				} else if ( name === "contains" ) {
  					return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
  				} else if ( name === "not" ) {
  					var not = match[3];
  					for ( var j = 0, l = not.length; j < l; j++ ) {
  						if ( not[j] === elem ) {
  							return false;
  						}
  					}
  					return true;
  				} else {
  					Sizzle.error( name );
  				}
  			},
  			CHILD: function( elem, match ) {
  				var first, last,
  					doneName, parent, cache,
  					count, diff,
  					type = match[1],
  					node = elem;
  				switch ( type ) {
  					case "only":
  					case "first":
  						while ( (node = node.previousSibling) ) {
  							if ( node.nodeType === 1 ) {
  								return false;
  							}
  						}
  						if ( type === "first" ) {
  							return true;
  						}
  						node = elem;
  					case "last":
  						while ( (node = node.nextSibling) ) {
  							if ( node.nodeType === 1 ) {
  								return false;
  							}
  						}
  						return true;
  					case "nth":
  						first = match[2];
  						last = match[3];
  						if ( first === 1 && last === 0 ) {
  							return true;
  						}
  						doneName = match[0];
  						parent = elem.parentNode;
  						if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
  							count = 0;
  							for ( node = parent.firstChild; node; node = node.nextSibling ) {
  								if ( node.nodeType === 1 ) {
  									node.nodeIndex = ++count;
  								}
  							}
  							parent[ expando ] = doneName;
  						}
  						diff = elem.nodeIndex - last;
  						if ( first === 0 ) {
  							return diff === 0;
  						} else {
  							return ( diff % first === 0 && diff / first >= 0 );
  						}
  				}
  			},
  			ID: function( elem, match ) {
  				return elem.nodeType === 1 && elem.getAttribute("id") === match;
  			},
  			TAG: function( elem, match ) {
  				return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
  			},
  			CLASS: function( elem, match ) {
  				return (" " + (elem.className || elem.getAttribute("class")) + " ")
  					.indexOf( match ) > -1;
  			},
  			ATTR: function( elem, match ) {
  				var name = match[1],
  					result = Sizzle.attr ?
  						Sizzle.attr( elem, name ) :
  						Expr.attrHandle[ name ] ?
  						Expr.attrHandle[ name ]( elem ) :
  						elem[ name ] != null ?
  							elem[ name ] :
  							elem.getAttribute( name ),
  					value = result + "",
  					type = match[2],
  					check = match[4];
  				return result == null ?
  					type === "!=" :
  					!type && Sizzle.attr ?
  					result != null :
  					type === "=" ?
  					value === check :
  					type === "*=" ?
  					value.indexOf(check) >= 0 :
  					type === "~=" ?
  					(" " + value + " ").indexOf(check) >= 0 :
  					!check ?
  					value && result !== false :
  					type === "!=" ?
  					value !== check :
  					type === "^=" ?
  					value.indexOf(check) === 0 :
  					type === "$=" ?
  					value.substr(value.length - check.length) === check :
  					type === "|=" ?
  					value === check || value.substr(0, check.length + 1) === check + "-" :
  					false;
  			},
  			POS: function( elem, match, i, array ) {
  				var name = match[2],
  					filter = Expr.setFilters[ name ];
  				if ( filter ) {
  					return filter( elem, i, match, array );
  				}
  			}
  		}
  	};
  	var origPOS = Expr.match.POS,
  		fescape = function(all, num){
  			return "\\" + (num - 0 + 1);
  		};
  	for ( var type in Expr.match ) {
  		Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
  		Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
  	}
  	Expr.match.globalPOS = origPOS;
  	var makeArray = function( array, results ) {
  		array = Array.prototype.slice.call( array, 0 );
  		if ( results ) {
  			results.push.apply( results, array );
  			return results;
  		}
  		return array;
  	};
  	try {
  		Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
  	} catch( e ) {
  		makeArray = function( array, results ) {
  			var i = 0,
  				ret = results || [];
  			if ( toString.call(array) === "[object Array]" ) {
  				Array.prototype.push.apply( ret, array );
  			} else {
  				if ( typeof array.length === "number" ) {
  					for ( var l = array.length; i < l; i++ ) {
  						ret.push( array[i] );
  					}
  				} else {
  					for ( ; array[i]; i++ ) {
  						ret.push( array[i] );
  					}
  				}
  			}
  			return ret;
  		};
  	}
  	var sortOrder, siblingCheck;
  	if ( document.documentElement.compareDocumentPosition ) {
  		sortOrder = function( a, b ) {
  			if ( a === b ) {
  				hasDuplicate = true;
  				return 0;
  			}
  			if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
  				return a.compareDocumentPosition ? -1 : 1;
  			}
  			return a.compareDocumentPosition(b) & 4 ? -1 : 1;
  		};
  	} else {
  		sortOrder = function( a, b ) {
  			if ( a === b ) {
  				hasDuplicate = true;
  				return 0;
  			} else if ( a.sourceIndex && b.sourceIndex ) {
  				return a.sourceIndex - b.sourceIndex;
  			}
  			var al, bl,
  				ap = [],
  				bp = [],
  				aup = a.parentNode,
  				bup = b.parentNode,
  				cur = aup;
  			if ( aup === bup ) {
  				return siblingCheck( a, b );
  			} else if ( !aup ) {
  				return -1;
  			} else if ( !bup ) {
  				return 1;
  			}
  			while ( cur ) {
  				ap.unshift( cur );
  				cur = cur.parentNode;
  			}
  			cur = bup;
  			while ( cur ) {
  				bp.unshift( cur );
  				cur = cur.parentNode;
  			}
  			al = ap.length;
  			bl = bp.length;
  			for ( var i = 0; i < al && i < bl; i++ ) {
  				if ( ap[i] !== bp[i] ) {
  					return siblingCheck( ap[i], bp[i] );
  				}
  			}
  			return i === al ?
  				siblingCheck( a, bp[i], -1 ) :
  				siblingCheck( ap[i], b, 1 );
  		};
  		siblingCheck = function( a, b, ret ) {
  			if ( a === b ) {
  				return ret;
  			}
  			var cur = a.nextSibling;
  			while ( cur ) {
  				if ( cur === b ) {
  					return -1;
  				}
  				cur = cur.nextSibling;
  			}
  			return 1;
  		};
  	}
  	(function(){
  		var form = document.createElement("div"),
  			id = "script" + (new Date()).getTime(),
  			root = document.documentElement;
  		form.innerHTML = "<a name='" + id + "'/>";
  		root.insertBefore( form, root.firstChild );
  		if ( document.getElementById( id ) ) {
  			Expr.find.ID = function( match, context, isXML ) {
  				if ( typeof context.getElementById !== "undefined" && !isXML ) {
  					var m = context.getElementById(match[1]);
  					return m ?
  						m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
  							[m] :
  							undefined :
  						[];
  				}
  			};
  			Expr.filter.ID = function( elem, match ) {
  				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
  				return elem.nodeType === 1 && node && node.nodeValue === match;
  			};
  		}
  		root.removeChild( form );
  		root = form = null;
  	})();
  	(function(){
  		var div = document.createElement("div");
  		div.appendChild( document.createComment("") );
  		if ( div.getElementsByTagName("*").length > 0 ) {
  			Expr.find.TAG = function( match, context ) {
  				var results = context.getElementsByTagName( match[1] );
  				if ( match[1] === "*" ) {
  					var tmp = [];
  					for ( var i = 0; results[i]; i++ ) {
  						if ( results[i].nodeType === 1 ) {
  							tmp.push( results[i] );
  						}
  					}
  					results = tmp;
  				}
  				return results;
  			};
  		}
  		div.innerHTML = "<a href='#'></a>";
  		if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
  				div.firstChild.getAttribute("href") !== "#" ) {
  			Expr.attrHandle.href = function( elem ) {
  				return elem.getAttribute( "href", 2 );
  			};
  		}
  		div = null;
  	})();
  	if ( document.querySelectorAll ) {
  		(function(){
  			var oldSizzle = Sizzle,
  				div = document.createElement("div"),
  				id = "__sizzle__";
  			div.innerHTML = "<p class='TEST'></p>";
  			if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
  				return;
  			}
  			Sizzle = function( query, context, extra, seed ) {
  				context = context || document;
  				if ( !seed && !Sizzle.isXML(context) ) {
  					var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
  					if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
  						if ( match[1] ) {
  							return makeArray( context.getElementsByTagName( query ), extra );
  						} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
  							return makeArray( context.getElementsByClassName( match[2] ), extra );
  						}
  					}
  					if ( context.nodeType === 9 ) {
  						if ( query === "body" && context.body ) {
  							return makeArray( [ context.body ], extra );
  						} else if ( match && match[3] ) {
  							var elem = context.getElementById( match[3] );
  							if ( elem && elem.parentNode ) {
  								if ( elem.id === match[3] ) {
  									return makeArray( [ elem ], extra );
  								}
  							} else {
  								return makeArray( [], extra );
  							}
  						}
  						try {
  							return makeArray( context.querySelectorAll(query), extra );
  						} catch(qsaError) {}
  					} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
  						var oldContext = context,
  							old = context.getAttribute( "id" ),
  							nid = old || id,
  							hasParent = context.parentNode,
  							relativeHierarchySelector = /^\s*[+~]/.test( query );
  						if ( !old ) {
  							context.setAttribute( "id", nid );
  						} else {
  							nid = nid.replace( /'/g, "\\$&" );
  						}
  						if ( relativeHierarchySelector && hasParent ) {
  							context = context.parentNode;
  						}
  						try {
  							if ( !relativeHierarchySelector || hasParent ) {
  								return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
  							}
  						} catch(pseudoError) {
  						} finally {
  							if ( !old ) {
  								oldContext.removeAttribute( "id" );
  							}
  						}
  					}
  				}
  				return oldSizzle(query, context, extra, seed);
  			};
  			for ( var prop in oldSizzle ) {
  				Sizzle[ prop ] = oldSizzle[ prop ];
  			}
  			div = null;
  		})();
  	}
  	(function(){
  		var html = document.documentElement,
  			matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
  		if ( matches ) {
  			var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
  				pseudoWorks = false;
  			try {
  				matches.call( document.documentElement, "[test!='']:sizzle" );
  			} catch( pseudoError ) {
  				pseudoWorks = true;
  			}
  			Sizzle.matchesSelector = function( node, expr ) {
  				expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
  				if ( !Sizzle.isXML( node ) ) {
  					try {
  						if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
  							var ret = matches.call( node, expr );
  							if ( ret || !disconnectedMatch ||
  									node.document && node.document.nodeType !== 11 ) {
  								return ret;
  							}
  						}
  					} catch(e) {}
  				}
  				return Sizzle(expr, null, null, [node]).length > 0;
  			};
  		}
  	})();
  	(function(){
  		var div = document.createElement("div");
  		div.innerHTML = "<div class='test e'></div><div class='test'></div>";
  		if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
  			return;
  		}
  		div.lastChild.className = "e";
  		if ( div.getElementsByClassName("e").length === 1 ) {
  			return;
  		}
  		Expr.order.splice(1, 0, "CLASS");
  		Expr.find.CLASS = function( match, context, isXML ) {
  			if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
  				return context.getElementsByClassName(match[1]);
  			}
  		};
  		div = null;
  	})();
  	function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
  		for ( var i = 0, l = checkSet.length; i < l; i++ ) {
  			var elem = checkSet[i];
  			if ( elem ) {
  				var match = false;
  				elem = elem[dir];
  				while ( elem ) {
  					if ( elem[ expando ] === doneName ) {
  						match = checkSet[elem.sizset];
  						break;
  					}
  					if ( elem.nodeType === 1 && !isXML ){
  						elem[ expando ] = doneName;
  						elem.sizset = i;
  					}
  					if ( elem.nodeName.toLowerCase() === cur ) {
  						match = elem;
  						break;
  					}
  					elem = elem[dir];
  				}
  				checkSet[i] = match;
  			}
  		}
  	}
  	function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
  		for ( var i = 0, l = checkSet.length; i < l; i++ ) {
  			var elem = checkSet[i];
  			if ( elem ) {
  				var match = false;
  				elem = elem[dir];
  				while ( elem ) {
  					if ( elem[ expando ] === doneName ) {
  						match = checkSet[elem.sizset];
  						break;
  					}
  					if ( elem.nodeType === 1 ) {
  						if ( !isXML ) {
  							elem[ expando ] = doneName;
  							elem.sizset = i;
  						}
  						if ( typeof cur !== "string" ) {
  							if ( elem === cur ) {
  								match = true;
  								break;
  							}
  						} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
  							match = elem;
  							break;
  						}
  					}
  					elem = elem[dir];
  				}
  				checkSet[i] = match;
  			}
  		}
  	}
  	if ( document.documentElement.contains ) {
  		Sizzle.contains = function( a, b ) {
  			return a !== b && (a.contains ? a.contains(b) : true);
  		};
  	} else if ( document.documentElement.compareDocumentPosition ) {
  		Sizzle.contains = function( a, b ) {
  			return !!(a.compareDocumentPosition(b) & 16);
  		};
  	} else {
  		Sizzle.contains = function() {
  			return false;
  		};
  	}
  	Sizzle.isXML = function( elem ) {
  		var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
  		return documentElement ? documentElement.nodeName !== "HTML" : false;
  	};
  	var posProcess = function( selector, context, seed ) {
  		var match,
  			tmpSet = [],
  			later = "",
  			root = context.nodeType ? [context] : context;
  		while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
  			later += match[0];
  			selector = selector.replace( Expr.match.PSEUDO, "" );
  		}
  		selector = Expr.relative[selector] ? selector + "*" : selector;
  		for ( var i = 0, l = root.length; i < l; i++ ) {
  			Sizzle( selector, root[i], tmpSet, seed );
  		}
  		return Sizzle.filter( later, tmpSet );
  	};
  	window.Sizzle = Sizzle;
  	})();
  	Util.querySelector = u.qs = function(query, target) {
  		var res = Sizzle(query, target);
  		return res[0];
  	}
  	Util.querySelectorAll = u.qsa = function(query, target) {
  		var res = Sizzle(query, target);
  		return res;
  	}
  }
  
  
  /*u-form-desktop_light.js*/
  Util.Form = u.f = new function() {
  	this.customInit = {};
  	this.customValidate = {};
  	this.customDataFormat = {};
  	this.customHintPosition = {};
  	this.init = function(_form, _options) {
  		var i, j, field, action, input, hidden_input;
  		_form._bulk_operation = true;
  		if(_form.nodeName.toLowerCase() != "form") {
  			_form.native_form = u.pn(_form, {"include":"form"});
  			if(!_form.native_form) {
  				u.bug("there is no form in this document??");
  				return;
  			}
  		}
  		else {
  			_form.native_form = _form;
  		}
  		_form._focus_z_index = 50;
  		_form._validation = true;
  		_form._debug = false;
  		_form._callback_ready = "ready";
  		_form._callback_submitted = "submitted";
  		_form._callback_pre_submitted = "preSubmitted";
  		_form._callback_resat = "resat";
  		_form._callback_updated = "updated";
  		_form._callback_changed = "changed";
  		_form._callback_blurred = "blurred";
  		_form._callback_focused = "focused";
  		_form._callback_input_validation_failed = "inputValidationFailed";
  		_form._callback_input_validation_passed = "inputValidationPassed";
  		_form._callback_validation_failed = "validationFailed";
  		_form._callback_validation_passed = "validationPassed";
  		if(obj(_options)) {
  			var _argument;
  			for(_argument in _options) {
  				switch(_argument) {
  					case "validation"               : _form._validation                = _options[_argument]; break;
  					case "debug"                    : _form._debug                     = _options[_argument]; break;
  					case "focus_z"                  : _form._focus_z_index             = _options[_argument]; break;
  					case "callback_ready"           : _form._callback_ready            = _options[_argument]; break;
  					case "callback_submitted"       : _form._callback_submitted        = _options[_argument]; break;
  					case "callback_pre_submitted"   : _form._callback_pre_submitted    = _options[_argument]; break;
  					case "callback_resat"           : _form._callback_resat            = _options[_argument]; break;
  					case "callback_updated"         : _form._callback_updated          = _options[_argument]; break;
  					case "callback_changed"         : _form._callback_changed          = _options[_argument]; break;
  					case "callback_blurred"         : _form._callback_blurred          = _options[_argument]; break;
  					case "callback_focused"         : _form._callback_focused          = _options[_argument]; break;
  					case "callback_input_validation_failed"   : _form._callback_input_validation_failed    = _options[_argument]; break;
  					case "callback_input_validation_passed"   : _form._callback_input_validation_passed    = _options[_argument]; break;
  					case "callback_validation_failed"         : _form._callback_validation_failed          = _options[_argument]; break;
  					case "callback_validation_passed"         : _form._callback_validation_passed          = _options[_argument]; break;
  				}
  			}
  		}
  		_form._hover_z_index = _form._focus_z_index - 1;
  		_form.native_form.onsubmit = function(event) {
  			if(event.target._form) {
  				return false;
  			}
  		}
  		_form.native_form.setAttribute("novalidate", "novalidate");
  		_form.DOMsubmit = _form.native_form.submit;
  		_form.submit = this._submit;
  		_form.DOMreset = _form.native_form.reset;
  		_form.reset = this._reset;
  		_form.getData = function(_options) {
  			return u.f.getFormData(this, _options);
  		}
  		_form.inputs = {};
  		_form.actions = {};
  		_form._error_inputs = {};
  		var fields = u.qsa(".field", _form);
  		for(i = 0; i < fields.length; i++) {
  			field = fields[i];
  			u.f.initField(_form, field);
  		}
  		var hidden_inputs = u.qsa("input[type=hidden]", _form);
  		for(i = 0; i < hidden_inputs.length; i++) {
  			hidden_input = hidden_inputs[i];
  			if(!_form.inputs[hidden_input.name]) {
  				_form.inputs[hidden_input.name] = hidden_input;
  				hidden_input._form = _form;
  				hidden_input.val = this._value;
  			}
  		}
  		var actions = u.qsa(".actions li input[type=button],.actions li input[type=submit],.actions li input[type=reset],.actions li a.button", _form);
  		for(i = 0; i < actions.length; i++) {
  			action = actions[i];
  			this.initButton(_form, action);
  		}
  		u.t.setTimer(_form, function() {
  			var validate_inputs = [];
  			for(input in this.inputs) {
  				if(this.inputs[input].field) {
  					validate_inputs.push(this.inputs[input]);
  				}
  			}
  			u.f.bulkValidate(validate_inputs);
  			if(_form._debug) {
  				u.bug(_form, "inputs:", _form.inputs, "actions:", _form.actions);
  			}
  			if(fun(this[this._callback_ready])) {
  				this[this._callback_ready]();
  			}
  		}, 100);
  	}
  	this.initField = function(_form, field) {
  		field._form = _form;
  		field._base_z_index = u.gcs(field, "z-index");
  		field.help = u.qs(".help", field);
  		field.hint = u.qs(".hint", field);
  		field.error = u.qs(".error", field);
  		field.label = u.qs("label", field);
  		field.indicator = u.ae(field.label, "span", {"class":"indicator", "html":"&nbsp;*"});
  		if(fun(u.f.fixFieldHTML)) {
  			u.f.fixFieldHTML(field);
  		}
  		field._custom_initialized = false;
  		var custom_init;
  		for(custom_init in this.customInit) {
  			if(u.hc(field, custom_init)) {
  				this.customInit[custom_init](field);
  				field._custom_initialized = true;
  				break;
  			}
  		}
  		if(!field._custom_initialized) {
  			if(u.hc(field, "string|email|tel|number|integer|password|date|datetime")) {
  				field.type = field.className.match(/(?:^|\b)(string|email|tel|number|integer|password|date|datetime)(?:\b|$)/)[0];
  				field.input = u.qs("input", field);
  				field.input._form = _form;
  				field.input.label = u.qs("label[for='"+field.input.id+"']", field);
  				field.input.field = field;
  				field.input.val = this._value;
  				u.e.addEvent(field.input, "keyup", this._updated);
  				u.e.addEvent(field.input, "change", this._changed);
  				this.inputOnEnter(field.input);
  				this.activateInput(field.input);
  			}
  			else if(u.hc(field, "text")) {
  				field.type = "text";
  				field.input = u.qs("textarea", field);
  				field.input._form = _form;
  				field.input.label = u.qs("label[for='"+field.input.id+"']", field);
  				field.input.field = field;
  				field.input.val = this._value;
  				if(u.hc(field, "autoexpand")) {
  					var current_height = parseInt(u.gcs(field.input, "height"));
  					var current_value = field.input.val();
  					field.input.value = "";
  					u.as(field.input, "overflow", "hidden");
  					field.input.autoexpand_offset = 0;
  					if(parseInt(u.gcs(field.input, "height")) != field.input.scrollHeight) {
  						field.input.autoexpand_offset = field.input.scrollHeight - parseInt(u.gcs(field.input, "height"));
  					}
  					field.input.value = current_value;
  					field.input.setHeight = function() {
  						var textarea_height = parseInt(u.gcs(this, "height"));
  						if(this.val()) {
  							if(u.browser("webkit") || u.browser("firefox", ">=29")) {
  								if(this.scrollHeight - this.autoexpand_offset > textarea_height) {
  									u.ass(this, {
  										"height":this.scrollHeight + "px"
  									});
  								}
  							}
  							else if(u.browser("opera") || u.browser("explorer")) {
  								if(this.scrollHeight > textarea_height) {
  									u.ass(this, {
  										"height":this.scrollHeight + "px"
  									});
  								}
  							}
  							else {
  								u.ass(this, {
  									"height":this.scrollHeight + "px"
  								});
  							}
  						}
  					}
  					u.e.addEvent(field.input, "keyup", field.input.setHeight);
  					field.input.setHeight();
  				}
  				u.e.addEvent(field.input, "keyup", this._updated);
  				u.e.addEvent(field.input, "change", this._changed);
  				this.activateInput(field.input);
  			}
  			else if(u.hc(field, "select")) {
  				field.type = "select";
  				field.input = u.qs("select", field);
  				field.input._form = _form;
  				field.input.label = u.qs("label[for='"+field.input.id+"']", field);
  				field.input.field = field;
  				field.input.val = this._value_select;
  				u.e.addEvent(field.input, "change", this._updated);
  				u.e.addEvent(field.input, "keyup", this._updated);
  				u.e.addEvent(field.input, "change", this._changed);
  				this.activateInput(field.input);
  			}
  			else if(u.hc(field, "checkbox|boolean")) {
  				field.type = field.className.match(/(?:^|\b)(checkbox|boolean)(?:\b|$)/)[0];
  				field.input = u.qs("input[type=checkbox]", field);
  				field.input._form = _form;
  				field.input.label = u.qs("label[for='"+field.input.id+"']", field);
  				field.input.field = field;
  				field.input.val = this._value_checkbox;
  				u.f._update_checkbox_field.bind(field.input)();
  				if(u.browser("explorer", "<=8")) {
  					field.input.pre_state = field.input.checked;
  					field.input._changed = this._changed;
  					field.input._updated = this._updated;
  					field.input._update_checkbox_field = this._update_checkbox_field;
  					field.input._clicked = function(event) {
  						if(this.checked != this.pre_state) {
  							this._changed(window.event);
  							this._updated(window.event);
  							this._update_checkbox_field(window.event);
  						}
  						this.pre_state = this.checked;
  					}
  					u.e.addEvent(field.input, "click", field.input._clicked);
  				}
  				else {
  					u.e.addEvent(field.input, "change", this._changed);
  					u.e.addEvent(field.input, "change", this._updated);
  					u.e.addEvent(field.input, "change", this._update_checkbox_field);
  				}
  				this.inputOnEnter(field.input);
  				this.activateInput(field.input);
  			}
  			else if(u.hc(field, "radiobuttons")) {
  				field.type = "radiobuttons";
  				field.inputs = u.qsa("input", field);
  				field.input = field.inputs[0];
  				for(j = 0; j < field.inputs.length; j++) {
  					input = field.inputs[j];
  					input._form = _form;
  					input.label = u.qs("label[for='"+input.id+"']", field);
  					input.field = field;
  					input.val = this._value_radiobutton;
  					if(u.browser("explorer", "<=8")) {
  						input.pre_state = input.checked;
  						input._changed = this._changed;
  						input._updated = this._updated;
  						input._clicked = function(event) {
  							var i, input;
  							if(this.checked != this.pre_state) {
  								this._changed(window.event);
  								this._updated(window.event);
  							}
  							for(i = 0; i < this.field.input.length; i++) {
  								input = this.field.input[i];
  								input.pre_state = input.checked;
  							}
  						}
  						u.e.addEvent(input, "click", input._clicked);
  					}
  					else {
  						u.e.addEvent(input, "change", this._changed);
  						u.e.addEvent(input, "change", this._updated);
  					}
  					this.inputOnEnter(input);
  					this.activateInput(input);
  				}
  			}
  			else if(u.hc(field, "files")) {
  				field.type = "files";
  				field.input = u.qs("input", field);
  				field.input._form = _form;
  				field.input.label = u.qs("label[for='"+field.input.id+"']", field);
  				field.input.field = field;
  				field.input.val = this._value_file;
  				field.filelist = u.qs("ul.filelist", field);
  				if(!field.filelist) {
  					field.filelist = u.ae(field, "ul", {"class":"filelist"});
  					field.insertBefore(field.help, field.filelist);
  				}
  				field.filelist.field = field;
  				field.uploaded_files = u.qsa("li.uploaded", field.filelist);
  				this._update_filelist.bind(field.input)();
  				u.e.addEvent(field.input, "change", this._updated);
  				u.e.addEvent(field.input, "change", this._changed);
  				u.e.addEvent(field.input, "change", this._update_filelist);
  				this.activateInput(field.input);
  			}
  			else {
  				u.bug("UNKNOWN FIELD IN FORM INITIALIZATION:", field, field.input);
  			}
  		}
  		if(field.input) {
  			_form.inputs[field.input.name] = field.input;
  			if(!_form._bulk_operation) {
  				this.validate(field.input);
  			}
  		}
  	}
  	this.initButton = function(_form, action) {
  		action._form = _form;
  		this.buttonOnEnter(action);
  		this.activateButton(action);
  	}
  	this._reset = function(event, iN) {
  		for (name in this.inputs) {
  			if (this.inputs[name] && this.inputs[name].field && this.inputs[name].type != "hidden" && !this.inputs[name].getAttribute("readonly")) {
  				this.inputs[name]._used = false;
  				this.inputs[name].val("");
  			}
  		}
  		if(fun(this[this._callback_resat])) {
  			this[this._callback_resat](iN);
  		}
  	}
  	this._submit = function(event, iN) {
  		var validate_inputs = [];
  		for(name in this.inputs) {
  			if(this.inputs[name] && this.inputs[name].field && fun(this.inputs[name].val)) {
  				this.inputs[name]._used = true;
  				validate_inputs.push(this.inputs[name]);
  			}
  		}
  		u.f.bulkValidate(validate_inputs);
  		if(!Object.keys(this._error_inputs).length) {
  			if(fun(this[this._callback_pre_submitted])) {
  				this[this._callback_pre_submitted](iN);
  			}
  			if(fun(this[this._callback_submitted])) {
  				this[this._callback_submitted](iN);
  			}
  			else {
  				for(name in this.inputs) {
  					if(this.inputs[name] && this.inputs[name].default_value && this.inputs[name].nodeName.match(/^(input|textarea)$/i)) {
  						if(fun(this.inputs[name].val) && !this.inputs[name].val()) {
  							this.inputs[name].value = "";
  						}
  					}
  				}
  				this.DOMsubmit();
  			}
  		}
  	}
  	this._value = function(value) {
  		if(value !== undefined) {
  			this.value = value;
  			if(value !== this.default_value) {
  				u.rc(this, "default");
  			}
  			u.f.validate(this);
  		}
  		return (this.value != this.default_value) ? this.value : "";
  	}
  	this._value_radiobutton = function(value) {
  		var i, option;
  		if(value !== undefined) {
  			for(i = 0; i < this.field.inputs.length; i++) {
  				option = this.field.inputs[i];
  				if(option.value == value || (option.value == "true" && value) || (option.value == "false" && value === false)) {
  					option.checked = true;
  					u.f.validate(this);
  				}
  				else {
  					option.checked = false;
  				}
  			}
  		}
  		for(i = 0; i < this.field.inputs.length; i++) {
  			option = this.field.inputs[i];
  			if(option.checked) {
  				return option.value;
  			}
  		}
  		return "";
  	}
  	this._value_checkbox = function(value) {
  		if(value !== undefined) {
  			if(value) {
  				this.checked = true
  			}
  			else {
  				this.checked = false;
  			}
  			u.f._update_checkbox_field.bind(this)();
  			u.f.validate(this);
  		}
  		if(this.checked) {
  			return this.value;
  		}
  		return "";
  	}
  	this._value_select = function(value) {
  		if(value !== undefined) {
  			var i, option;
  			for(i = 0; i < this.options.length; i++) {
  				option = this.options[i];
  				if(option.value == value) {
  					this.selectedIndex = i;
  					u.f.validate(this);
  					return this.options[this.selectedIndex].value;
  				}
  			}
  			if (value === "") {
  				this.selectedIndex = -1;
  				u.f.validate(this);
  				return "";
  			}
  		}
  		return (this.selectedIndex >= 0 && this.default_value != this.options[this.selectedIndex].value) ? this.options[this.selectedIndex].value : "";
  	}
  	this._value_file = function(value) {
  		if(value !== undefined) {
  			if(value === "") {
  				this.value = null;
  			}
  			else {
  				u.bug('ADDING VALUES MANUALLY TO INPUT type="file" IS NOT SUPPORTED IN JAVASCRIPT');
  			}
  			u.f._update_filelist.bind(this)();
  			u.f.validate(this);
  		}
  		if(this.files && this.files.length) {
  			var i, file, files = [];
  			for(i = 0; i < this.files.length; i++) {
  				file = this.files[i];
  				files.push(file);
  			}
  			return files;
  		}
  		else if(!this.files && this.value) {
  			return this.value;
  		}
  		else if(this.field.uploaded_files && this.field.uploaded_files.length){
  			return true;
  		}
  		return "";
  	}
  	this._changed = function(event) {
  		if(fun(this[this._form._callback_changed])) {
  			this[this._form._callback_changed](this);
  		}
  		else if(fun(this.field.input[this._form._callback_changed])) {
  			this.field.input[this._form._callback_changed](this);
  		}
  		if(fun(this._form[this._form._callback_changed])) {
  			this._form[this._form._callback_changed](this);
  		}
  	}
  	this._updated = function(event) {
  		if(event.keyCode != 9 && event.keyCode != 13 && event.keyCode != 16 && event.keyCode != 17 && event.keyCode != 18) {
  			u.f.validate(this);
  			if(fun(this[this._form._callback_updated])) {
  				this[this._form._callback_updated](this);
  			}
  			else if(fun(this.field.input[this._form._callback_updated])) {
  				this.field.input[this._form._callback_updated](this);
  			}
  			if(fun(this._form[this._form._callback_updated])) {
  				this._form[this._form._callback_updated](this);
  			}
  		}
  	}
  	this._update_checkbox_field = function(event) {
  		if(this.checked) {
  			u.ac(this.field, "checked");
  		}
  		else {
  			u.rc(this.field, "checked");
  		}
  	}
  	this._update_filelist = function(event) {
  		var i;
  		var files = this.val();
  		this.field.filelist.innerHTML = "";
  		u.ae(this.field.filelist, "li", {html:this.field.hint ? u.text(this.field.hint) : u.text(this.label), class:"label"})
  		if(files && files.length) {
  			u.ac(this.field, "has_new_files");
  			var i;
  			for(i = 0; i < files.length; i++) {
  				u.ae(this.field.filelist, "li", {html:files[i].name, class:"new"})
  			}
  			if(this.multiple) {
  				for(i = 0; i < this.field.uploaded_files.length; i++) {
  					u.ae(this.field.filelist, this.field.uploaded_files[i]);
  				}
  			}
  		}
  		else if(this.field.uploaded_files && this.field.uploaded_files.length) {
  			u.rc(this.field, "has_new_files");
  			var i;
  			for(i = 0; i < this.field.uploaded_files.length; i++) {
  				u.ae(this.field.filelist, this.field.uploaded_files[i]);
  			}
  		}
  		else {
  			u.rc(this.field, "has_new_files");
  		}
  	}
  	this._mouseenter = function(event) {
  		u.ac(this.field, "hover");
  		u.ac(this, "hover");
  		u.as(this.field, "zIndex", this._form._hover_z_index);
  		u.f.positionHint(this.field);
  	}
  	this._mouseleave = function(event) {
  		u.rc(this.field, "hover");
  		u.rc(this, "hover");
  		u.as(this.field, "zIndex", this.field._base_z_index);
  		u.f.positionHint(this.field);
  	}
  	this._focus = function(event) {
  		this.field.is_focused = true;
  		this.is_focused = true;
  		u.ac(this.field, "focus");
  		u.ac(this, "focus");
  		u.as(this.field, "zIndex", this._form._focus_z_index);
  		u.f.positionHint(this.field);
  		if(fun(this[this._form._callback_focused])) {
  			this[this._form._callback_focused]();
  		}
  		else if(fun(this.field.input[this._form._callback_focused])) {
  			this.field.input[this._form._callback_focused](this);
  		}
  		if(fun(this._form[this._form._callback_focused])) {
  			this._form[this._form._callback_focused](this);
  		}
  	}
  	this._blur = function(event) {
  		this.field.is_focused = false;
  		this.is_focused = false;
  		u.rc(this.field, "focus");
  		u.rc(this, "focus");
  		u.as(this.field, "zIndex", this.field._base_z_index);
  		u.f.positionHint(this.field);
  		this._used = true;
  		if(fun(this[this._form._callback_blurred])) {
  			this[this._form._callback_blurred]();
  		}
  		else if(fun(this.field.input[this._form._callback_blurred])) {
  			this.field.input[this._form._callback_blurred](this);
  		}
  		if(fun(this._form[this._form._callback_blurred])) {
  			this._form[this._form._callback_blurred](this);
  		}
  	}
  	this._button_focus = function(event) {
  		u.ac(this, "focus");
  		if(fun(this[this._form._callback_focused])) {
  			this[this._form._callback_focused]();
  		}
  		if(fun(this._form[this._form._callback_focused])) {
  			this._form[this._form._callback_focused](this);
  		}
  	}
  	this._button_blur = function(event) {
  		u.rc(this, "focus");
  		if(fun(this[this._form._callback_blurred])) {
  			this[this._form._callback_blurred]();
  		}
  		if(fun(this._form[this._form._callback_blurred])) {
  			this._form[this._form._callback_blurred](this);
  		}
  	}
  	this._validate = function(event) {
  		u.f.validate(this);
  	}
  	this.inputOnEnter = function(node) {
  		node.keyPressed = function(event) {
  			if(this.nodeName.match(/input/i) && (event.keyCode == 40 || event.keyCode == 38)) {
  				this._submit_disabled = true;
  			}
  			else if(this.nodeName.match(/input/i) && this._submit_disabled && (
  				event.keyCode == 46 || 
  				(event.keyCode == 39 && u.browser("firefox")) || 
  				(event.keyCode == 37 && u.browser("firefox")) || 
  				event.keyCode == 27 || 
  				event.keyCode == 13 || 
  				event.keyCode == 9 ||
  				event.keyCode == 8
  			)) {
  				this._submit_disabled = false;
  			}
  			else if(event.keyCode == 13 && !this._submit_disabled) {
  				u.e.kill(event);
  				this.blur();
  				this._form.submitInput = this;
  				this._form.submitButton = false;
  				this._form.submit(event, this);
  			}
  		}
  		u.e.addEvent(node, "keydown", node.keyPressed);
  	}
  	this.buttonOnEnter = function(node) {
  		node.keyPressed = function(event) {
  			if(event.keyCode == 13 && !u.hc(this, "disabled") && fun(this.clicked)) {
  				u.e.kill(event);
  				this.clicked(event);
  			}
  		}
  		u.e.addEvent(node, "keydown", node.keyPressed);
  	}
  	this.activateInput = function(iN) {
  		u.e.addEvent(iN, "focus", this._focus);
  		u.e.addEvent(iN, "blur", this._blur);
  		if(u.e.event_support != "touch") {
  			u.e.addEvent(iN, "mouseenter", this._mouseenter);
  			u.e.addEvent(iN, "mouseleave", this._mouseleave);
  		}
  		u.e.addEvent(iN, "blur", this._validate);
  		iN.default_value = "";
  	}
  	this.activateButton = function(action) {
  		if(action.type && action.type == "submit" || action.type == "reset") {
  			action.onclick = function(event) {
  				u.e.kill(event ? event : window.event);
  			}
  		}
  		u.ce(action);
  		if(!action.clicked) {
  			action.clicked = function(event) {
  				if(!u.hc(this, "disabled")) {
  					if(this.type && this.type.match(/submit/i)) {
  						this._form._submit_button = this;
  						this._form._submit_input = false;
  						this._form.submit(event, this);
  					}
  					else if(this.type && this.type.match(/reset/i)) {
  						this._form._submit_button = false;
  						this._form._submit_input = false;
  						this._form.reset(event, this);
  					}
  					else if(this.url) {
  						if(event && (event.metaKey || event.ctrlKey)) {
  							window.open(this.url);
  						}
  						else {
  							if(obj(u.h) && u.h.is_listening) {
  								u.h.navigate(this.url, this);
  							}
  							else {
  								location.href = this.url;
  							}
  						}
  					}
  				}
  			}
  		}
  		var action_name = action.name ? action.name : (action.parentNode.className ? u.superNormalize(action.parentNode.className) : (action.value ? u.superNormalize(action.value) : u.superNormalize(u.text(action))));
  		if(action_name && !action._form.actions[action_name]) {
  			action._form.actions[action_name] = action;
  		}
  		if(obj(u.k) && u.hc(action, "key:[a-z0-9]+")) {
  			u.k.addKey(action, u.cv(action, "key"));
  		}
  		u.e.addEvent(action, "focus", this._button_focus);
  		u.e.addEvent(action, "blur", this._button_blur);
  	}
  	this.positionHint = function(field) {
  		if(field.help) {
  			var custom_hint_position;
  			for(custom_hint_position in this.customHintPosition) {
  				if(u.hc(field, custom_hint_position)) {
  					this.customHintPosition[custom_hint_position](field);
  					return;
  				}
  			}
  			var input_middle = field.input.offsetTop + (field.input.offsetHeight / 2);
  			var help_top = input_middle - field.help.offsetHeight / 2;
  			u.ass(field.help, {
  				"top": help_top + "px"
  			});
  		}
  	}
  	this.updateFilelistStatus = function(form, response) {
  		if(form && form.inputs && response && response.cms_status == "success" && response.cms_object && response.cms_object.mediae) {
  			var mediae = JSON.parse(JSON.stringify(response.cms_object.mediae));
  			var filelists = u.qsa("div.field.files ul.filelist", form);
  			var i, j, k, filelist, old_files, old_file, new_files, new_files;
  			for(i = 0; i < filelists.length; i++) {
  				filelist = filelists[i];
  				new_files = u.qsa("li.new", filelist);
  				if(new_files.length) {
  					old_files = u.qsa("li.uploaded", filelist);
  					if(old_files.length) {
  						for(j in mediae) {
  							media = mediae[j];
  							if(media.variant.match("^" + filelist.field.input.name.replace(/\[\]$/, "") + "(\-|$)")) {
  								for(k = 0; k < old_files.length; k++) {
  									old_file = old_files[k];
  									if(u.cv(old_file, "media_id") == media.id) {
  										delete mediae[j];
  									}
  								}
  							}
  						}
  					}
  					if(Object.keys(mediae).length) {
  						for(j in mediae) {
  							media = mediae[j];
  							if(media.variant.match("^"+filelist.field.input.name.replace(/\[\]$/, "")+"(\-|$)")) {
  								for(k = 0; k < new_files.length; k++) {
  									new_file = new_files[k];
  									if(u.text(new_file) == media.name || u.text(new_file)+".zip" == media.name) {
  										new_file.innerHTML = media.name;
  										u.rc(new_file, "new");
  										u.ac(new_file, "uploaded media_id:"+media.id+" variant:"+media.variant+" format:"+media.format+" width:"+media.width+" height:"+media.height);
  										delete mediae[j];
  									}
  								}
  							}
  						}
  					}
  				}
  				filelist.field.uploaded_files = u.qsa("li.uploaded", filelist);
  			}
  		}
  	}
  	this.inputHasError = function(iN) {
  		u.rc(iN, "correct");
  		u.rc(iN.field, "correct");
  		delete iN.is_correct;
  		if(iN.val() !== "") {
  			if(!iN.has_error && (iN._used || iN._form._bulk_operation)) {
  				iN._form._error_inputs[iN.name] = true;
  				u.ac(iN, "error");
  				u.ac(iN.field, "error");
  				iN.has_error = true;
  				this.updateInputValidationState(iN);
  			 }
  		}
  		else if(!iN.has_error && iN._used) {
  			iN._form._error_inputs[iN.name] = true;
  			u.ac(iN, "error");
  			u.ac(iN.field, "error");
  			iN.has_error = true;
  			this.updateInputValidationState(iN);
  		}
  		else if(!iN._used) {
  			delete iN._form._error_inputs[iN.name];
  			u.rc(iN, "error");
  			u.rc(iN.field, "error");
  			delete iN.has_error;
  		}
  		this.positionHint(iN.field);
  	}
  	this.inputIsCorrect = function(iN) {
  		u.rc(iN, "error");
  		u.rc(iN.field, "error");
  		delete iN.has_error;
  		delete iN._form._error_inputs[iN.name];
  		if(iN.val() !== "") {
  			if(!iN.is_correct) {
  				iN._used = true;
  				u.ac(iN, "correct");
  				u.ac(iN.field, "correct");
  				iN.is_correct = true;
  				this.updateInputValidationState(iN);
  			}
  		}
  		else if(iN.is_correct || iN.has_error) {
  			u.rc(iN, "correct");
  			u.rc(iN.field, "correct");
  			delete iN.is_correct;
  			this.updateInputValidationState(iN);
  		}
  	}
  	this.updateInputValidationState = function(iN) {
  		if(iN.has_error && fun(iN[iN._form._callback_input_validation_failed])) {
  			iN[iN._form._callback_input_validation_failed]();
  		}
  		else if(iN.is_correct && fun(iN[iN._form._callback_input_validation_passed])) {
  			iN[iN._form._callback_input_validation_passed]();
  		}
  		this.updateFormValidationState(iN._form);
  	}
  	this.updateFormValidationState = function(_form) {
  		if(!_form._bulk_operation) {
  			if(Object.keys(_form._error_inputs).length) {
  				_form._validation_state = "error";
  				if(_form._error_inputs !== _form._reference_error_inputs) {
  					if(fun(_form[_form._callback_validation_failed])) {
  						_form[_form._callback_validation_failed](_form._error_inputs);
  					}
  				}
  			}
  			else if(u.qsa(".field.required", _form).length === u.qsa(".field.required.correct", _form).length) {
  				if(fun(_form[_form._callback_validation_passed]) && _form._validation_state !== "correct") {
  					_form[_form._callback_validation_passed]();
  				}
  				_form._validation_state = "correct";
  			}
  			else {
  				_form._validation_state = "void";
  			}
  			_form._reference_error_inputs = JSON.parse(JSON.stringify(_form._error_inputs));
  		}
  	}
  	this.bulkValidate = function(inputs) {
  		if(inputs && inputs.length) {
  			var _form = inputs[0]._form;
  			_form._bulk_operation = true;
  			var i;
  			for(i = 0; i < inputs.length; i++) {
  				u.f.validate(inputs[i]);
  			}
  			_form._bulk_operation = false;
  			this.updateFormValidationState(_form);
  		}
  	}
  	this.validate = function(iN) {
  		if(!iN._form._validation || !iN.field) {
  			return true;
  		}
  		var min, max, pattern;
  		var validated = false;
  		var compare_to = iN.getAttribute("data-compare-to");
  		if(!u.hc(iN.field, "required") && iN.val() === "" && (!compare_to || iN._form.inputs[compare_to].val() === "")) {
  			this.inputIsCorrect(iN);
  			return true;
  		}
  		else if(u.hc(iN.field, "required") && iN.val() === "") {
  			this.inputHasError(iN);
  			return false;
  		}
  		var custom_validate;
  		for(custom_validate in u.f.customValidate) {
  			if(u.hc(iN.field, custom_validate)) {
  				u.f.customValidate[custom_validate](iN);
  				validated = true;
  			}
  		}
  		if(!validated) {
  			if(u.hc(iN.field, "password")) {
  				min = Number(u.cv(iN.field, "min"));
  				max = Number(u.cv(iN.field, "max"));
  				min = min ? min : 8;
  				max = max ? max : 255;
  				pattern = iN.getAttribute("pattern");
  				if(
  					iN.val().length >= min && 
  					iN.val().length <= max && 
  					(!pattern || iN.val().match("^"+pattern+"$")) &&
  					(!compare_to || iN.val() == iN._form.inputs[compare_to].val())
  				) {
  					this.inputIsCorrect(iN);
  					if(compare_to) {
  						this.inputIsCorrect(iN._form.inputs[compare_to]);
  					}
  				}
  				else {
  					this.inputHasError(iN);
  					if(compare_to) {
  						this.inputHasError(iN._form.inputs[compare_to]);
  					}
  				}
  			}
  			else if(u.hc(iN.field, "number")) {
  				min = Number(u.cv(iN.field, "min"));
  				max = Number(u.cv(iN.field, "max"));
  				min = min ? min : 0;
  				max = max ? max : 99999999999999999999999999999;
  				pattern = iN.getAttribute("pattern");
  				if(
  					!isNaN(iN.val()) && 
  					iN.val() >= min && 
  					iN.val() <= max && 
  					(!pattern || iN.val().match("^"+pattern+"$"))
  				) {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "integer")) {
  				min = Number(u.cv(iN.field, "min"));
  				max = Number(u.cv(iN.field, "max"));
  				min = min ? min : 0;
  				max = max ? max : 99999999999999999999999999999;
  				pattern = iN.getAttribute("pattern");
  				if(
  					!isNaN(iN.val()) && 
  					Math.round(iN.val()) == iN.val() && 
  					iN.val() >= min && 
  					iN.val() <= max && 
  					(!pattern || iN.val().match("^"+pattern+"$"))
  				) {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "tel")) {
  				pattern = iN.getAttribute("pattern");
  				if(
  					(
  						(!pattern && iN.val().match(/^([\+0-9\-\.\s\(\)]){5,18}$/)) 
  						||
  						(pattern && iN.val().match("^"+pattern+"$"))
  					)
  					&&
  					(!compare_to || iN.val() == iN._form.inputs[compare_to].val())
  				) {
  					this.inputIsCorrect(iN);
  					if(compare_to) {
  						this.inputIsCorrect(iN._form.inputs[compare_to]);
  					}
  				}
  				else {
  					this.inputHasError(iN);
  					if(compare_to) {
  						this.inputHasError(iN._form.inputs[compare_to]);
  					}
  				}
  			}
  			else if(u.hc(iN.field, "email")) {
  				pattern = iN.getAttribute("pattern");
  				if(
  					(
  						(!pattern && iN.val().match(/^([^<>\\\/%$])+\@([^<>\\\/%$])+\.([^<>\\\/%$]{2,20})$/)) 
  						||
  						(pattern && iN.val().match("^"+pattern+"$"))
  					)
  					&&
  					(!compare_to || iN.val() == iN._form.inputs[compare_to].val())
  				) {
  					this.inputIsCorrect(iN);
  					if(compare_to) {
  						this.inputIsCorrect(iN._form.inputs[compare_to]);
  					}
  				}
  				else {
  					this.inputHasError(iN);
  					if(compare_to) {
  						this.inputHasError(iN._form.inputs[compare_to]);
  					}
  				}
  			}
  			else if(u.hc(iN.field, "text")) {
  				min = Number(u.cv(iN.field, "min"));
  				max = Number(u.cv(iN.field, "max"));
  				min = min ? min : 1;
  				max = max ? max : 10000000;
  				pattern = iN.getAttribute("pattern");
  				if(
  					iN.val().length >= min && 
  					iN.val().length <= max && 
  					(!pattern || iN.val().match("^"+pattern+"$"))
  				) {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "date")) {
  				min = u.cv(iN.field, "min");
  				max = u.cv(iN.field, "max");
  				pattern = iN.getAttribute("pattern");
  				if(
  					(!min || new Date(decodeURIComponent(min)) <= new Date(iN.val())) &&
  					(!max || new Date(decodeURIComponent(max)) >= new Date(iN.val())) &&
  					(
  						(!pattern && iN.val().match(/^([\d]{4}[\-\/\ ]{1}[\d]{2}[\-\/\ ][\d]{2})$/))
  						||
  						(pattern && iN.val().match("^"+pattern+"$"))
  					)
  				) {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "datetime")) {
  				min = u.cv(iN.field, "min");
  				max = u.cv(iN.field, "max");
  				pattern = iN.getAttribute("pattern");
  				if(
  					(!min || new Date(decodeURIComponent(min)) <= new Date(iN.val())) &&
  					(!max || new Date(decodeURIComponent(max)) >= new Date(iN.val())) &&
  					(
  						(!pattern && iN.val().match(/^([\d]{4}[\-\/\ ]{1}[\d]{2}[\-\/\ ][\d]{2} [\d]{2}[\-\/\ \:]{1}[\d]{2}[\-\/\ \:]{0,1}[\d]{0,2})$/))
  						||
  						(pattern && iN.val().match(pattern))
  					)
  				) {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "files")) {
  				min = Number(u.cv(iN.field, "min"));
  				max = Number(u.cv(iN.field, "max"));
  				min = min ? min : 1;
  				max = max ? max : 10000000;
  				pattern = iN.getAttribute("accept");
  				var i, value = iN.val(), files = [];
  				if(iN.field.uploaded_files && iN.field.uploaded_files.length) {
  					for(i = 0; i < iN.field.uploaded_files.length; i++) {
  						files.push("." + u.cv(iN.field.uploaded_files[i], "format").toLowerCase());
  					}
  				}
  				if(value && value.length) {
  					for(i = 0; i < value.length; i++) {
  						files.push(value[i].name.substring(value[i].name.lastIndexOf(".")));
  					}
  				}
  				if(
  					(files.length >= min && files.length <= max)
  					&&
  					(!pattern || files.every(function(v) {return pattern.split(",").indexOf(v) !== -1}))
  				) {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "select")) {
  				if(iN.val() !== "") {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "checkbox|boolean|radiobuttons")) {
  				if(iN.val() !== "") {
  					this.inputIsCorrect(iN);
  				}
  				else {
  					this.inputHasError(iN);
  				}
  			}
  			else if(u.hc(iN.field, "string")) {
  				min = Number(u.cv(iN.field, "min"));
  				max = Number(u.cv(iN.field, "max"));
  				min = min ? min : 1;
  				max = max ? max : 255;
  				pattern = iN.getAttribute("pattern");
  				if(
  					iN.val().length >= min &&
  					iN.val().length <= max && 
  					(!pattern || iN.val().match("^"+pattern+"$"))
  					&&
  					(!compare_to || iN.val() == iN._form.inputs[compare_to].val())
  				) {
  					this.inputIsCorrect(iN);
  					if(compare_to) {
  						this.inputIsCorrect(iN._form.inputs[compare_to]);
  					}
  				}
  				else {
  					this.inputHasError(iN);
  					if(compare_to) {
  						this.inputHasError(iN._form.inputs[compare_to]);
  					}
  				}
  			}
  		}
  		if(u.hc(iN.field, "error")) {
  			return false;
  		}
  		else {
  			return true;
  		}
  	}
  	this.getFormData = this.getParams = function(_form, _options) {
  		var format = "params";
  		var ignore_inputs = "ignoreinput";
  		if(obj(_options)) {
  			var _argument;
  			for(_argument in _options) {
  				switch(_argument) {
  					case "ignore_inputs"    : ignore_inputs     = _options[_argument]; break;
  					case "format"           : format            = _options[_argument]; break;
  				}
  			}
  		}
  		var i, input, select, textarea, param, params;
  		if(format == "formdata" && (fun(window.FormData) || obj(window.FormData))) {
  			params = new FormData();
  		}
  		else {
  			if(format == "formdata") {
  				format == "params";
  			}
  			params = new Object();
  			params.append = function(name, value, filename) {
  				this[name] = filename || value;
  			}
  		}
  		if(_form._submit_button && _form._submit_button.name) {
  			params.append(_form._submit_button.name, _form._submit_button.value);
  		}
  		var inputs = u.qsa("input", _form);
  		var selects = u.qsa("select", _form)
  		var textareas = u.qsa("textarea", _form)
  		for(i = 0; i < inputs.length; i++) {
  			input = inputs[i];
  			if(!u.hc(input, ignore_inputs)) {
  				if((input.type == "checkbox" || input.type == "radio") && input.checked) {
  					if(fun(input.val)) {
  						params.append(input.name, input.val());
  					}
  					else {
  						params.append(input.name, input.value);
  					}
  				}
  				else if(input.type == "file") {
  					var f, file, files;
  					if(fun(input.val)) {
  						files = input.val();
  					}
  					else if(input.files) {
  						files = input.files;
  					}
  					if(files && files.length) {
  						for(f = 0; f < files.length; f++) {
  							file = files[f];
  							params.append(input.name, file, file.name);
  						}
  					}
  					else {
  						params.append(input.name, "");
  					}
  				}
  				else if(!input.type.match(/button|submit|reset|file|checkbox|radio/i)) {
  					if(fun(input.val)) {
  						params.append(input.name, input.val());
  					}
  					else {
  						params.append(input.name, input.value);
  					}
  				}
  			}
  		}
  		for(i = 0; i < selects.length; i++) {
  			select = selects[i];
  			if(!u.hc(select, ignore_inputs)) {
  				if(fun(select.val)) {
  					params.append(select.name, select.val());
  				}
  				else {
  					params.append(select.name, select.options[select.selectedIndex] ? select.options[select.selectedIndex].value : "");
  				}
  			}
  		}
  		for(i = 0; i < textareas.length; i++) {
  			textarea = textareas[i];
  			if(!u.hc(textarea, ignore_inputs)) {
  				if(fun(textarea.val)) {
  					params.append(textarea.name, textarea.val());
  				}
  				else {
  					params.append(textarea.name, textarea.value);
  				}
  			}
  		}
  		if(format && fun(this.customDataFormat[format])) {
  			return this.customDataFormat[format](params, _form);
  		}
  		else if(format == "formdata") {
  			return params;
  		}
  		else if(format == "object") {
  			delete params.append;
  			return params;
  		}
  		else {
  			var string = "";
  			for(param in params) {
  				if(!fun(params[param])) {
  					string += (string ? "&" : "") + param + "=" + encodeURIComponent(params[param]);
  				}
  			}
  			return string;
  		}
  	}
  }
  
  
  /*u-events-desktop_light.js*/
  if(document.all && document.addEventListener == undefined) {
  	window.attachedEvents = {};
  	window.eventHandler = function(eid) {
  		var element, i;
  		if(eid != "window") {
  			element = u.ge("eid:"+eid);
  		}
  		else {
  			element = window;
  		}
  		var win_event = new Object();
  		for(x in window.event) {
  			win_event[x] = window.event[x];
  		}
  		win_event.target = element;
  		win_event.currentTarget = element;
  		win_event.timeStamp = new Date().getTime();
  		if(element && eid && window.attachedEvents[eid] && window.attachedEvents[eid][window.event.type]) {
  			var i, attachedAction;
  			for(i = 0; i < window.attachedEvents[eid][window.event.type].length; i++) {
  				attachedAction = window.attachedEvents[eid][window.event.type][i];
  				element.ie_event_action = attachedAction;
  				element.ie_event_action(win_event);
  			}
  		}
  		return;
  	}
  	u.e.event_pref = "mouse";
  	u.e.event_support = "mouse";
  	u.e.kill = function(event) {
  		if(event) {
  			event.cancelBubble = true;
  			event.returnValue = false;
  		}
  	}
  	u.e.addEvent = function(node, type, action) {
  		if(obj(node) && typeof(node.childNodes) == "undefined") {
  			node["on"+ type] = action;
  			return;
  		}
  		else if(node != window) {
  			var eid = u.cv(node, "eid");
  			if(!eid) {
  				var eid = u.randomString();
  				u.ac(node, "eid:"+eid)
  			}
  		}
  		else {
  			eid = "window";
  		}
  		if(!window.attachedEvents[eid]) {
  			window.attachedEvents[eid] = {};
  		}
  		if(!window.attachedEvents[eid][type]) {
  			window.attachedEvents[eid][type] = new Array();
  		}
  		if(window.attachedEvents[eid][type].length == 0) {
  			eval('node._'+type+'eventhandler = function() {window.eventHandler("'+eid+'")}');
  			node.attachEvent("on"+type, node["_"+type+"eventhandler"]);
  		}
  		if(window.attachedEvents[eid][type].indexOf(action) == -1) {
  			window.attachedEvents[eid][type].push(action);
  		}
  	}
  	u.e.removeEvent = function(node, type, action) {
  		if(obj(node) && typeof(node.childNodes) == "undefined") {
  			node["on"+ type] = null;
  			return;
  		}
  		else if(node != window) {
  			var eid = u.cv(node, "eid");
  		}
  		else {
  			eid = "window";
  		}
  		if(eid && window.attachedEvents[eid] && window.attachedEvents[eid][type]) {
  			for(i in window.attachedEvents[eid][type]) {
  				if(window.attachedEvents[eid][type][i] == action) {
  					window.attachedEvents[eid][type].splice(i,1);
  					if(!window.attachedEvents[eid][type].length) {
  						node.detachEvent("on"+type, node["_"+type+"eventhandler"])
  					}
  				}
  			}
  		}
  	}
  }
  
  
  /*u-geometry-desktop_light.js*/
  Util.actualWidth = u.actualW = function(node) {
  	var width = parseInt(u.gcs(node, "width"));
  	if(isNaN(width) || u.browser("opera", "<=9")) {
  		return node.offsetWidth - parseInt(u.gcs(node, "padding-left")) - parseInt(u.gcs(node, "padding-right"));
  	}
  	else {
  		return width;
  	}
  }
  Util.actualHeight = u.actualH = function(node) {
  	var height = parseInt(u.gcs(node, "height"));
  	if(isNaN(height) || u.browser("opera", "<=9")) {
  		return node.offsetHeight - parseInt(u.gcs(node, "padding-top")) - parseInt(u.gcs(node, "padding-bottom"));
  	}
  	else {
  		return height;
  	}
  }
  Util.eventX = function(event){
  	if(event.targetTouches && event.targetTouches.length) {
  		return event.targetTouches[0].pageX;
  	}
  	else if(event.pageX != undefined) {
  		return event.pageX;
  	}
  	else if(event.clientX != undefined) {
  		return event.clientX + document.documentElement.scrollLeft;
  	}
  	else {
  		return 0;
  	}
  }
  Util.eventY = function(event){
  	if(event.targetTouches && event.targetTouches.length) {
  		return event.targetTouches[0].pageY;
  	}
  	else if(event.pageY != undefined) {
  		return event.pageY;
  	}
  	else if(event.clientY != undefined) {
  		return event.clientY + document.documentElement.scrollTop;
  	}
  	else {
  		return 0;
  	}
  }
  Util.pageScrollX = u.scrollX = function() {
  	if(window.pageXOffset != undefined) {
  		return window.pageXOffset;
  	}
  	else if(document.documentElement.scrollLeft != undefined) {
  		return document.documentElement.scrollLeft;
  	}
  	else {
  		return 0;
  	}
  }
  Util.pageScrollY = u.scrollY = function() {
  	if(window.pageYOffset != undefined) {
  		return window.pageYOffset;
  	}
  	else if(document.documentElement.scrollTop != undefined) {
  		return document.documentElement.scrollTop;
  	}
  	else {
  		return 0;
  	}
  }
  
  
  /*u-json-desktop_light.js*/
  if (typeof JSON !== 'object') {
      JSON = {};
  }
  (function () {
      'use strict';
      function f(n) {
          return n < 10 ? '0' + n : n;
      }
      if (typeof Date.prototype.toJSON !== 'function') {
          Date.prototype.toJSON = function (key) {
              return isFinite(this.valueOf())
                  ? this.getUTCFullYear()     + '-' +
                      f(this.getUTCMonth() + 1) + '-' +
                      f(this.getUTCDate())      + 'T' +
                      f(this.getUTCHours())     + ':' +
                      f(this.getUTCMinutes())   + ':' +
                      f(this.getUTCSeconds())   + 'Z'
                  : null;
          };
          String.prototype.toJSON      =
              Number.prototype.toJSON  =
              Boolean.prototype.toJSON = function (key) {
                  return this.valueOf();
              };
      }
      var cx = new RegExp("[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]", "g"),
          escapable = new RegExp("[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]", "g"),
          gap,
          indent,
          meta = {    
              '\b': '\\b',
              '\t': '\\t',
              '\n': '\\n',
              '\f': '\\f',
              '\r': '\\r',
              '"' : '\\"',
              '\\': '\\\\'
          },
          rep;
      function quote(string) {
          escapable.lastIndex = 0;
          return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
              var c = meta[a];
              return typeof c === 'string'
                  ? c
                  : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
          }) + '"' : '"' + string + '"';
      }
      function str(key, holder) {
          var i,          
              k,          
              v,          
              length,
              mind = gap,
              partial,
              value = holder[key];
          if (value && typeof value === 'object' &&
                  typeof value.toJSON === 'function') {
              value = value.toJSON(key);
          }
          if (typeof rep === 'function') {
              value = rep.call(holder, key, value);
          }
          switch (typeof value) {
          case 'string':
              return quote(value);
          case 'number':
              return isFinite(value) ? String(value) : 'null';
          case 'boolean':
          case 'null':
              return String(value);
          case 'object':
              if (!value) {
                  return 'null';
              }
              gap += indent;
              partial = [];
              if (Object.prototype.toString.apply(value) === '[object Array]') {
                  length = value.length;
                  for (i = 0; i < length; i += 1) {
                      partial[i] = str(i, value) || 'null';
                  }
                  v = partial.length === 0
                      ? '[]'
                      : gap
                      ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
                      : '[' + partial.join(',') + ']';
                  gap = mind;
                  return v;
              }
              if (rep && typeof rep === 'object') {
                  length = rep.length;
                  for (i = 0; i < length; i += 1) {
                      if (typeof rep[i] === 'string') {
                          k = rep[i];
                          v = str(k, value);
                          if (v) {
                              partial.push(quote(k) + (gap ? ': ' : ':') + v);
                          }
                      }
                  }
              } else {
                  for (k in value) {
                      if (Object.prototype.hasOwnProperty.call(value, k)) {
                          v = str(k, value);
                          if (v) {
                              partial.push(quote(k) + (gap ? ': ' : ':') + v);
                          }
                      }
                  }
              }
              v = partial.length === 0
                  ? '{}'
                  : gap
                  ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
                  : '{' + partial.join(',') + '}';
              gap = mind;
              return v;
          }
      }
      if (typeof JSON.stringify !== 'function') {
          JSON.stringify = function (value, replacer, space) {
              var i;
              gap = '';
              indent = '';
              if (typeof space === 'number') {
                  for (i = 0; i < space; i += 1) {
                      indent += ' ';
                  }
              } else if (typeof space === 'string') {
                  indent = space;
              }
              rep = replacer;
              if (replacer && typeof replacer !== 'function' &&
                      (typeof replacer !== 'object' ||
                      typeof replacer.length !== 'number')) {
                  throw new Error('JSON.stringify');
              }
              return str('', {'': value});
          };
      }
      if (typeof JSON.parse !== 'function') {
          JSON.parse = function (text, reviver) {
              var j;
              function walk(holder, key) {
                  var k, v, value = holder[key];
                  if (value && typeof value === 'object') {
                      for (k in value) {
                          if (Object.prototype.hasOwnProperty.call(value, k)) {
                              v = walk(value, k);
                              if (v !== undefined) {
                                  value[k] = v;
                              } else {
                                  delete value[k];
                              }
                          }
                      }
                  }
                  return reviver.call(holder, key, value);
              }
              text = String(text);
              cx.lastIndex = 0;
              if (cx.test(text)) {
                  text = text.replace(cx, function (a) {
                      return '\\u' +
                          ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
                  });
              }
              if (/^[\],:{}\s]*$/
                      .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
                          .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
                          .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
                  j = eval('(' + text + ')');
                  return typeof reviver === 'function'
                      ? walk({'': j}, '')
                      : j;
              }
              throw new SyntaxError('JSON.parse');
          };
      }
  }());
  
  