try {
    document.domain="mail.ru";
} catch(e) {
}


/*jslint evil: true */

// Augment the basic prototypes if they have not already been augmented.

if (!Object.prototype.toJSONString) {

    Array.prototype.toJSONString = function () {
        var a = ['['],  // The array holding the text fragments.
            b,          // A boolean indicating that a comma is required.
            i,          // Loop counter.
            l = this.length,
            v;          // The value to be stringified.

        function p(s) {

// p accumulates text fragments in an array. It inserts a comma before all
// except the first fragment.

            if (b) {
                a.push(',');
            }
            a.push(s);
            b = true;
        }

// For each value in this array...

        for (i = 0; i < l; i += 1) {
            v = this[i];
            switch (typeof v) {

// Serialize a JavaScript object value. Ignore objects thats lack the
// toJSONString method. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

            case 'object':
                if (v) {
                    if (typeof v.toJSONString === 'function') {
                        p(v.toJSONString());
                    }
                } else {
                    p("null");
                }
                break;

// Otherwise, serialize the value.

            case 'string':
            case 'number':
            case 'boolean':
				p(v.toJSONString());

// Values without a JSON representation are ignored.

            }
        }

// Join all of the fragments together and return.

        a.push(']');
        return a.join('');
    };


    Boolean.prototype.toJSONString = function () {
        return String(this);
    };


    Date.prototype.toJSONString = function () {

// Ultimately, this method will be equivalent to the date.toISOString method.

        function f(n) {

// Format integers to have at least two digits.

            return n < 10 ? '0' + n : n;
        }

        return '"' + this.getFullYear() + '-' +
                f(this.getMonth() + 1) + '-' +
                f(this.getDate()) + 'T' +
                f(this.getHours()) + ':' +
                f(this.getMinutes()) + ':' +
                f(this.getSeconds()) + '"';
    };


    Number.prototype.toJSONString = function () {

// JSON numbers must be finite. Encode non-finite numbers as null.
        return isFinite(this) ? String(this) : "null";
    };


    Object.prototype.toJSONString = function () {
        var a = ['{'],  // The array holding the text fragments.
            b,          // A boolean indicating that a comma is required.
            k,          // The current key.
            v;          // The current value.

        function p(s) {

// p accumulates text fragment pairs in an array. It inserts a comma before all
// except the first fragment pair.

            if (b) {
                a.push(',');
            }
            a.push(k.toJSONString(), ':', s);
            b = true;
        }

// Iterate through all of the keys in the object, ignoring the proto chain.

        for (k in this) {
            if (this.hasOwnProperty(k)) {
                v = this[k];
                switch (typeof v) {

// Serialize a JavaScript object value. Ignore objects that lack the
// toJSONString method. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

                case 'object':
                    if (v) {
                        if (typeof v.toJSONString === 'function') {
                            p(v.toJSONString());
                        }
                    } else {
                        p("null");
                    }
                    break;

                case 'string':
                case 'number':
                case 'boolean':
                    p(v.toJSONString());

// Values without a JSON representation are ignored.

                }
            }
        }

// Join all of the fragments together and return.

        a.push('}');
        return a.join('');
    };


    (function (s) {

// Augment String.prototype. We do this in an immediate anonymous function to
// avoid defining global variables.

// m is a table of character substitutions.

        var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        };


        s.parseJSON = function (filter) {
            var j;

            function walk(k, v) {
                var i;
                if (v && typeof v === 'object') {
                    for (i in v) {
                        if (v.hasOwnProperty(i)) {
                            v[i] = walk(i, v[i]);
                        }
                    }
                }
                return filter(k, v);
            }


// Parsing happens in three stages. In the first stage, we run the text against
// a regular expression which looks for non-JSON characters. We are especially
// concerned with '()' and 'new' because they can cause invocation, and '='
// because it can cause mutation. But just to be safe, we will reject all
// unexpected characters.

            if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
                    test(this)) {

// In the second stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.

                try {
                    j = eval('(' + this + ')');
                } catch (e) {
                    throw new SyntaxError("parseJSON");
                }
            } else {
                throw new SyntaxError("parseJSON");
            }

// In the optional third stage, we recursively walk the new structure, passing
// each name/value pair to a filter function for possible transformation.

            if (typeof filter === 'function') {
                j = walk('', j);
            }
            return j;
        };


        s.toJSONString = function () {

// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can simply slap some quotes around it.
// Otherwise we must also replace the offending characters with safe
// sequences.
            if (/["\\\x00-\x1f]/.test(this)) {
                return '"' + this.replace(/([\x00-\x1f\\"])/g, function (a, b) {
                    var c = m[b];
                    if (c) {
                        return c;
                    }
                    c = b.charCodeAt();
                    return '\\u00' +
                        Math.floor(c / 16).toString(16) +
                        (c % 16).toString(16);
                }) + '"';
            }
            return '"' + this + '"';
        };
    })(String.prototype);
}

/* JSON END */

    var ajax_requests = [];
    var ajaxHandleStateChange = function() {
	for(var k = 0; k<ajax_requests.length; k++) {
	    if (ajax_requests[k].request == null) {
		ajax_requests.splice(k--,1);
		continue;
	    }
	    if (ajax_requests[k].request.readyState == 4) {
		var request = ajax_requests[k];
		ajax_requests.splice(k--,1);
		try {
		    request.ready();
		} catch (e) {}
		continue;
	    }
	}
    }

    function GetAjaxRequest()
    {
	var request = null;
	// branch for native XMLHttpRequest object
	if (typeof XMLHttpRequest != "undefined") {
	    try {
		request = new XMLHttpRequest();
	    } catch(e) {
		request = null;
	    }
	// branch for IE/Windows ActiveX version
	} else if(window.ActiveXObject) {
	    try {
		request = new ActiveXObject("Msxml2.XMLHTTP");
	    } catch(e) {
    		try {
		    request = new ActiveXObject("Microsoft.XMLHTTP");
    	    	} catch(e) {
          	    request = null;
    		}
	    }
	}
	return request;
    }

    function AjaxRequest(method,script_name,func_name,args,callback,callback_object)
    {
	this.method = method;
	this.callback = callback;
	this.callback_object = callback_object;
	this.args = args;
	if (func_name && func_name != 'undefined')
	{
		this.url = script_name+"?ajax_call=1&func_name="+escapePlus(func_name)+"&back="+escapePlus(window.location)+"&data="+escapePlus(this.args.toJSONString());
	}
	else
	{
		this.url = script_name;
	}

    }

    AjaxRequest.prototype = {
	send : function() {
	    var request = GetAjaxRequest();
	    if (request) {
		this.request = request;
		request.onreadystatechange = ajaxHandleStateChange;
		if (this.method == "POST") {
		    var idx=this.url.indexOf('?');
		    var post = this.url.substr(idx+1);
		    var url = this.url.substr(0,idx);
		    try {
		      // some old browsers would trigger security error here
		      request.open("POST", url, true);
		    } catch(e) {
		      return false;
		    }
		    request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
		    try {
		      // Opera 8.54 hung here, not on request.open
		      request.send(post);
		    } catch(e) {
		      return false;
		    }
		} else {
		    try {
		      request.open("GET", this.url, true);
		    } catch(e) {
		      return false;
		    }
		    try {
		      // Opera 8.54
		      request.send(null);
		    } catch(e) {
		      return false;
		    }
		}
		return true;
	    } else {
		return false;
	    }
	},
	ready : function() {
	    if(this.request.status != 200) return;
	    var data = eval(this.request.responseText);
	    var magick = data.shift();
	    if(magick != "AjaxResponse") return;
	    var result = data.shift();
            if(result != "OK" && result != "Redirect") return;
            if(result == "OK") {
	        if(this.callback) {
		    this.callback.apply(this.callback_object?this.callback_object:window,data);
	        }
            }
	    else if(result == "Redirect") {
                redirect.apply(window,data);
            }
	    return;
	}
    }

    function redirect(url)
    {
        window.location=url;
    }

    function escapePlus(param){
        param = escape(param);
        return String(param).replace(/\+/g,'%2B');
    }

    function escapeParam(param)
    {
        return String(param).replace(/\\/g,"\\\\").replace(/&/g,"\\&");
    }

    function unescapeParam(param)
    {
        return String(param).replace(/\\&/g,"&").replace(/\\\\/g,"\\");
    }

    function splitParam(param)
    {
	if(param == "") return new Array();
        var params = unescapeParam(param).split("&");
	for(var i = 0; i<params.length; i++) {
	    if(params[i].substr(params[i].length-1,1) == "\\" && params.length>i+1) {
                params.splice(i,2,params[i]+"&"+params[i+1]);
                i--;
	    }
        }
	for(var i = 0; i<params.length; i++)
	    params[i]=params[i].substr(1,params[i].length-2);
        return params;
    }
//////////////////////////////



function ajax_call_static() { 
	var args = ajax_call_static.arguments; 
	var url = args[0]; 
	var callback = args[1]; 

	var pos = ajax_requests.length; 
	var request = new AjaxRequest("GET",url,'','',callback,''); 
	ajax_requests[pos] = request; 
	if (!request.send()) { 
		ajax_requests.splice(ajax_requests.length-1,1); 
		return false; 
	} else { 
		return true; 
	} 
}