if(typeof CF == "undefined") CF = {};

(function($, $name) {

var Sys = $.Sys = {};

if(!$.Function) $.Function = {};

var $createDelegate = $.Function.createDelegate = function(instance, method) {
    return function() {
        return method.apply(instance, arguments);
    };
};
$.Type = {};

var $registerNamespace = $.Type.registerNamespace = function(namespacePath) {
    var rootObject = $, namespaceParts = namespacePath.split('.');

    for (var i = 0; i < namespaceParts.length; i++) {
        var currentPart = namespaceParts[i];
        var ns = rootObject[currentPart];
        if (!ns) {
            ns = rootObject[currentPart] = {};
        }
        rootObject = ns;
    }
};

var $registerClass = $.Type.registerClass = function(type, typeName, baseType) {
    type.prototype.constructor = type;
    type.__typeName = typeName;
    if(baseType) {
        type.__baseType = baseType;
        for (var memberName in baseType.prototype) {
            var memberValue = baseType.prototype[memberName];
            if (!type.prototype[memberName]) {
                type.prototype[memberName] = memberValue;
            }
        }
    }
    
    type.initializeBase = function(instance, baseArguments) {
                                this.callBaseMethod(instance, null, baseArguments);
                            };
                                    
    type.callBaseMethod = function(instance, name, baseArguments) {
                                if (this.__baseType) {
                                    var baseMethod = name ? this.__baseType.prototype[name] : this.__baseType;
                                    if(baseArguments)
                                        return baseMethod.apply(instance, baseArguments);
                                    else
                                        return baseMethod.apply(instance);
                                }

                            };
};
var $registerEnum = $.Type.registerEnum = function(type) {
    for (var i in type.prototype) {
        type[i] = type.prototype[i];
    }
    
    type.toString = function(value) {
        var values = type.prototype, i;
        for (i in values) {
            if (values[i] === value) return i;
        }
    
        return null;
    };
};

if(!$.Array) $.Array = {};

$.Array.indexOf = function (array, item, start) {
    if (typeof(item) != "undefined") {
        for (var i = (start || 0); i < array.length; i++) {
            if ((typeof(array[i]) != "undefined") && (array[i] === item)) {
                return i;
            }
        }
    }
    return -1;
};
$.Array.contains = function(array, item) {
    return ($.Array.indexOf(array, item) >= 0);
};
$.Array.remove = function(array, item) {
    var index = $.Array.indexOf(array, item);
    if (index >= 0) array.splice(index, 1);
    return (index >= 0);
};

if(!$.String) $.String = {};

$.String.format = function() {
    var args = arguments;
    return args[0].replace(/\{\d+\}/g, function(capture){ return args[parseInt(capture.match(/\d+/), 10) + 1]; });
}

$registerNamespace('Sys');

var $Browser = Sys.Browser = {};
$Browser.InternetExplorer = {};
$Browser.agent = null;
var $UserAgent = navigator.userAgent;
if ($UserAgent.indexOf(' MSIE ') > -1) {
    $Browser.agent = $Browser.InternetExplorer;
    $Browser.version = parseFloat($UserAgent.match(/MSIE (\d+\.\d+)/)[1]);
}

$registerNamespace('Sys.UI');

var $MouseButton = Sys.UI.MouseButton = function() { };
$MouseButton.prototype = {
    leftButton: 0,
    middleButton: 1,
    rightButton: 2
};
$registerEnum($MouseButton);

var $Key = Sys.UI.Key = function() { };
$Key.prototype = {
    backspace: 8,
    tab: 9,
    enter: 13,
    esc: 27,
    space: 32,
    pageUp: 33,
    pageDown: 34,
    end: 35,
    home: 36,
    left: 37,
    up: 38,
    right: 39,
    down: 40,
    del: 127
};
$registerEnum($Key);

Sys.UI.Point = function(x, y) {
    this.x = x;
    this.y = y;
};
Sys.UI.Bounds = function(x, y, width, height) {
    this.x = x;
    this.y = y;
    this.height = height;
    this.width = width;
};
var $DomElement = Sys.UI.DomElement = { };
$DomElement.getBounds = function(element) {
    var offset = $DomElement.getLocation(element);

    return new Sys.UI.Bounds(offset.x, offset.y, element.offsetWidth || 0, element.offsetHeight || 0);
};
$.$get = $DomElement.getElementById = function(id, element) {
    return (element || document).getElementById(id);
};
$DomElement.getLocation = function (element) {
    var x = 0, y = 0, tagName = element.tagName;
    
    if(tagName != "BODY" && tagName != "HTML") {
        if($Browser.agent == $Browser.InternetExplorer) {
            if (!element.self && element.nodeType != 9){
                var clientRect = element.getBoundingClientRect();
                if (clientRect) {
                    var ownerDocument = element.ownerDocument, documentElement = ownerDocument.documentElement
                        f = ownerDocument.frameElement, offset = (f && (f.frameBorder == "0" || f.frameBorder == "no")) ? 2 : 0;
                    x = clientRect.left - 2 + documentElement.scrollLeft + offset,
                    y = clientRect.top - 2 + documentElement.scrollTop + offset;
                }
            }
        }
        else {
            do {
                x += element.offsetLeft;
                y += element.offsetTop;
            } while(element = element.offsetParent);
        }
        
    }
    
    return new Sys.UI.Point(x, y);
};
$DomElement.containsCssClass = function(element, className) {
    return (' ' + element.className + ' ').indexOf(' ' + className + ' ') >= 0;
};

$DomElement.addCssClass = function(element, className) {
    if (!$DomElement.containsCssClass(element, className)) {
        if (!element.className) element.className = className;
        else element.className += ' ' + className;
    }
};
$DomElement.removeCssClass = function (element, className) {
    var currentClassName = ' ' + element.className + ' ';
    var index = currentClassName.indexOf(' ' + className + ' ');
    if (index >= 0) element.className = currentClassName.substr(0, index) + ' ' + currentClassName.substring(index + className.length + 1, currentClassName.length);
};

$DomElement.setLocation = function(element, x, y) {
    var style = element.style;
    style.position = 'absolute';
    style.left = x + "px";
    style.top = y + "px";
};
var $DomEvent = Sys.UI.DomEvent = function(eventObject) {
    var e = eventObject;
    this.rawEvent = e;
    this.altKey = e.altKey;
    if (typeof(e.button) != 'undefined') {
        this.button = (typeof(e.which) != 'undefined') ? e.button :
            (e.button == 4) ? $MouseButton.middleButton :
            (e.button == 2) ? $MouseButton.rightButton :
            $MouseButton.leftButton;
    }
    
    if (e.type == 'keypress') this.charCode = e.charCode || e.keyCode;
    else if (e.keyCode && (e.keyCode == 46)) this.keyCode = 127;
    else this.keyCode = e.keyCode;
    
    this.clientX = e.clientX;
    this.clientY = e.clientY;
    this.ctrlKey = e.ctrlKey;
    this.target = e.target ? e.target : e.srcElement;
    if (this.target) {
        var loc = $DomElement.getLocation(this.target);
        this.offsetX = (typeof(e.offsetX) != 'undefined') ? e.offsetX : window.pageXOffset + (e.clientX || 0) - loc.x;
        this.offsetY = (typeof(e.offsetY) != 'undefined') ? e.offsetY : window.pageYOffset + (e.clientY || 0) - loc.y;
    }
    this.screenX = e.screenX;
    this.screenY = e.screenY;
    this.shiftKey = e.shiftKey;
    this.type = e.type;
};
$DomEvent.prototype = {
    preventDefault: function() {
        if (this.rawEvent.preventDefault) this.rawEvent.preventDefault();
        else if (window.event) window.event.returnValue = false;
    },
    stopPropagation: function() {
        if (this.rawEvent.stopPropagation) this.rawEvent.stopPropagation();
        else if (window.event) window.event.cancelBubble = true;
    }
};

var $addHandler = $.$addHandler = $DomEvent.addHandler = function(element, eventName, handler) {
    if (!element._events) element._events = {};
    
    var eventCache = element._events[eventName], browserHandler;
    if (!eventCache) {
        element._events[eventName] = eventCache = [];
    }
    
    if (element.addEventListener) {
        browserHandler = function(e) 
                            {
                                return handler.call(element, new $DomEvent(e));
                            };
        element.addEventListener(eventName, browserHandler, false);
    }
    else if (element.attachEvent) {
        browserHandler = function()
                            {
                                return handler.call(element, new $DomEvent(window.event));
                            };
        element.attachEvent('on' + eventName, browserHandler);
    }
    eventCache[eventCache.length] = {handler: handler, browserHandler: browserHandler};
};

var $removeHandler = $.$removeHandler = $DomEvent.removeHandler = function(element, eventName, handler) {
    var cache = element._events[eventName];
    for (var i = 0, l = cache.length; i < l; i++) {
        if (cache[i].handler == handler) {
            if (element.removeEventListener) element.removeEventListener(eventName, cache[i].browserHandler, false);
            else if (element.detachEvent) element.detachEvent('on' + eventName, cache[i].browserHandler);
            
            cache.splice(i, 1);
            break;
        }
    }
};
var $EventHandlerList = Sys.EventHandlerList = function() {
    this._list = {};
};
$EventHandlerList.prototype = {
    addHandler: function(id, handler) {
        var evt = this._getEvent(id, true);
        evt[evt.length] = handler;
    },
    removeHandler: function(id, handler) {
        var evt = this._getEvent(id);
        if (!evt) return;
        $.Array.remove(evt, handler);
    },
    getHandler: function(id) {
        var evt = this._getEvent(id);
        if (!evt || (evt.length == 0)) return null;
        if (!evt._handler) {
            evt._handler = function(source, args) 
                            {
                                for (var i = 0, l = evt.length; i < l; i++) {
                                    evt[i](source, args);
                                }
                            };
        }
        return evt._handler;
    },
    _getEvent: function (id, create) {
        if (!this._list[id]) {
            if (!create) return null;
            this._list[id] = [];
        }
        return this._list[id];
    }
};

var $EventArgs = Sys.EventArgs = function() { };
$EventArgs.Empty = new $EventArgs();

var $PropertyChangedEventArgs = Sys.PropertyChangedEventArgs = function(propertyName) {
    this._propertyName = propertyName;
};
$PropertyChangedEventArgs.prototype = {
    get_propertyName : function() {
        return this._propertyName;
    }
};
$.__components = { };
var $Component = Sys.Component = function () {};
$Component.prototype = {
   get_events : function () {
        if (!this._events) this._events = new $EventHandlerList();
        return this._events;
    },
    get_id : function() {
        return this._id;
    },
    set_id : function(value) {
        this._id = value;
    },
    add_propertyChanged : function(handler) {
        this.get_events().addHandler("propertyChanged", handler);
    },
    remove_propertyChanged : function(handler) {
        this.get_events().removeHandler("propertyChanged", handler);
    },
    raisePropertyChanged : function(propertyName) {
        var handler = this.get_events().getHandler("propertyChanged");
        if (handler) handler(this, new $PropertyChangedEventArgs(propertyName));
    },
    initialize : function() {
        $.__components[this.get_id()] = this;
    },
    dispose : function() {
        delete $.__components[this.get_id()];
    }
};
$Component._setProperties = function(component, properties, prefix, find) {
    if (properties) {
        for (var name in properties) {
            var accessor = component[prefix + name], val = properties[name];
            if (typeof(accessor) == 'function') accessor.apply(component, [find ? $.$find(val) : val]);
        }
    }
};
$Component._setReferences = function() {
    var references = $Component._references, i = 0;
    if(references) {
        for(; i < references.length; i++) {
            $Component._setProperties(references[i].component, references[i].references, "set_", true);
        }
        
        $Component._references = null;
    }
};
$.$create = $Component.create = function(type, properties, events, references, element) {
    var component = element ? new type(element): new type();
    
    $Component._setProperties(component, properties, "set_");
    
    if(component.initialize) component.initialize();
    
    $Component._setProperties(component, events, "add_");
    
    if(references) {
        if(!$Component._references) $Component._references = [];
        $Component._references.push( { "component" : component, "references" : references } );
    }
    
    return component;
};
var $Behavior = Sys.UI.Behavior = function (element) {
    Sys.UI.Behavior.initializeBase(this);

    this._element = element;
};
$Behavior.prototype = {
    get_element : function() {
        return this._element;
    },
    get_name : function() {
        var name;
        if(this.constructor && this.constructor.__typeName) {
            name = this.constructor.__typeName;
            var i = name.lastIndexOf('.');
            if (i != -1) name = name.substr(i + 1);
        }
        return name;
    },
    get_id : function() {
        var baseId = $Behavior.callBaseMethod(this, 'get_id');
        if (baseId) return baseId;
        if (!this._element || !this._element.id) return '';
        return this._element.id + '$' + this.get_name();
   }
};

$registerClass($Behavior, 'Sys.UI.Behavior', $Component);

var $_Application = function() {
    this._initialized = false;
    this._loaded = false;
    this._onInitialize$ = null;
    this._onload$ = $createDelegate(this, this._onLoad);
    this._onUnload$ = $createDelegate(this, this._onUnload);

    $DomEvent.addHandler(window, "load", this._onload$);
    $DomEvent.addHandler(window, "unload", this._onUnload$);
};
$_Application.prototype = {
    getComponents : function() {
        var components = [];
        for (var name in $.__components) {
            components.push($.__components[name]);
        }
        return components;
    },
    add_load : function(handler) {
        this._addHandler("load", handler, this._loaded);
    },
    add_init : function(handler) {
        this._addHandler("init", handler, this._initialized);
    },
    initialize : function() {
        if(!this._onInitialize$) {
            this._onInitialize$ = $createDelegate(this, this._onInitialize);
            window.setTimeout(this._onInitialize$, 0);
        }
    },
    notifyScriptLoaded : function() {
    },
    dispose : function() {
        $DomEvent.removeHandler(window, "load", this._onload$);
        $DomEvent.removeHandler(window, "unload", this._onUnload$);
        var components = this.getComponents(), i = 0;
        for(; i < components.length; i++) {
            if(components[i].dispose) components[i].dispose();
        }
    },
    _onInitialize : function() {
        if(!this._initialized) {
            this._onEvent("init");
            this._initialized = true;
        }
    },
    _onLoad : function() {
        this._onInitialize();
        this._onEvent("load");
        this._loaded = true;
    },
    _onUnload : function() {
        this.dispose();
    },
    _addHandler : function(name, handler, past) {
        if(past) {
            handler(this, $EventArgs.Empty);
            $Component._setReferences();
        }
        else this.get_events().addHandler(name, handler);
    },
    _onEvent : function(name) {
        var h = this.get_events().getHandler(name);
        if (h) h(this, $EventArgs.Empty);
        $Component._setReferences();
    }
};
$registerClass($_Application, '', $Component);

var $Application = Sys.Application = new $_Application();
$.$find = $Application.findComponent = function(id) {
    return $.__components ? $.__components[id] : null;
};

var $CultureInfo = Sys.CultureInfo = function (name, numberFormat, dateTimeFormat) {
    this.name = name;
    this.numberFormat = numberFormat;
    this.dateTimeFormat = dateTimeFormat;
};

if(!$.Date) $.Date = {};
var $Date = $.Date;
$Date._appendPreOrPostMatch = function (preMatch, val) {
    var quoteCount = 0, escaped = false;
    for (var i = 0; i < preMatch.length; i++) {
        var c = preMatch.charAt(i);
        switch (c) {
            case '\'':
                if (escaped) val.str += "'";
                else quoteCount++;
                escaped = false;
                break;
            case '\\':
                if (escaped) val.str += "\\";
                escaped = !escaped;
                break;
            default:
                val.str += c;
                escaped = false;
                break;
        }
    }
    
    val.quoteCount += quoteCount;
};

$Date._expandFormat = function (dtf, format) {
    if(!format || format == "d") return dtf.ShortDatePattern;
    else if(format == "t") return dtf.ShortTimePattern;
    
    return format;
};

$Date._getParseRegExp = function (dtf, format) {
    if (!dtf._parseRegExp)  dtf._parseRegExp = {};
    else if (dtf._parseRegExp[format]) return dtf._parseRegExp[format];

    var expFormat = $Date._expandFormat(dtf, format);
    expFormat = expFormat.replace(/([\^\$\.\*\+\?\|\[\]\(\)\{\}])/g, "\\\\$1");

    var regexp = { "quoteCount" : 0, "str" : "^\\s*" }, groups = [], index = 0, tokenRegExp = $Date._getTokenRegExp(), match;

    while ((match = tokenRegExp.exec(expFormat)) != null) {
        var preMatch = expFormat.slice(index, match.index);
        index = tokenRegExp.lastIndex;

        $Date._appendPreOrPostMatch(preMatch, regexp);
        if ((regexp.quoteCount % 2) == 1) {
            regexp.str += match[0];
            continue;
        }

        switch (match[0]) {
            case 'yyyy':
                regexp.str += "(\\d{4})";
                break;
            case 'dd': case 'd':
            case 'MM': case 'M':
            case 'yy': case 'y':
                regexp.str += "(\\d\\d?)";
                break;
        }
        groups[groups.length] = match[0];
    }
    $Date._appendPreOrPostMatch(expFormat.slice(index), regexp);
    regexp.str += "\\s*$";
    var regexpStr = regexp.str.replace(/\s+/g, "\\s+");
    var parseRegExp = {'regExp': regexpStr, 'groups': groups};
    dtf._parseRegExp[format] = parseRegExp;
    return parseRegExp;
};

$Date._getTokenRegExp = function() {
        return /dd|d|MMMM|MM|M|yyyy|hh|h|HH|H|mm|m|tt/g;
};

$Date.parseLocale = function(value, formats) {
    return $Date._parse(value, $CultureInfo.CurrentCulture, arguments);
};

$Date.parseInvariant = function(value, formats) {
    return $Date._parse(value, $CultureInfo.InvariantCulture, arguments);
};

$Date._parse = function(value, cultureInfo, args) {  
    var custom = (args[1]), formats = custom ? args : [cultureInfo.dateTimeFormat.ShortDatePattern], start = custom ? 1 : 0;
    for (var i = start; i < formats.length; i++) {
        var format = formats[i], date;
        if (format) {
            date = $Date._parseExact(value, format, cultureInfo);
            if (date) return date;
        }
    }
    return null;
};

$Date._parseExact = function(value, format, cultureInfo) {
    var dtf = cultureInfo.dateTimeFormat, parseInfo = $Date._getParseRegExp(dtf, format), match = new RegExp(parseInfo.regExp).exec(value);
    if (match) {
        var groups = parseInfo.groups, year = null, month = null, date = null;
        
        for (var j = 0, jl = groups.length; j < jl; j++) {
            var matchGroup = match[j+1];
            if (matchGroup) {
                switch (groups[j]) {
                    case 'dd': case 'd':
                        date = parseInt(matchGroup, 10);
                        break;
                    case 'M': case 'MM':
                        month = parseInt(matchGroup, 10) - 1;
                        break;
                    case 'yyyy':
                        year = parseInt(matchGroup, 10);
                        break;
                }
            }
        }
        var result = new Date(year, month, date);
        if (result.getDate() != date) return null;
        return result;
    }
};
$Date._toFormattedString = function(date, format, cultureInfo) {
    var dtf = cultureInfo.dateTimeFormat, padd = function(num, req)
                            {
                                return (req && num < 10 ? '0' : '') + num;
                            },
         ret = { "quoteCount" : 0, "str" : "" }, tokenRegExp = $Date._getTokenRegExp(), hour, token;
                  
    format = $Date._expandFormat(dtf, format);

    for (;;) {
        var index = tokenRegExp.lastIndex, ar = tokenRegExp.exec(format), preMatch = format.slice(index, ar ? ar.index : format.length);
        
        $Date._appendPreOrPostMatch(preMatch, ret);

        if (!ar) break;

        token = ar[0];
        
        if (ret.quoteCount % 2 == 1) {
            ret.str += token;
            continue;
        }

        switch (token) {
            case "d":
            case "dd":
                ret.str += padd(date.getDate(), token == "dd");
                break;
            case "MMMM":
                ret.str += dtf.MonthNames[date.getMonth()];
                break;
            case "MM":
            case "M":
                ret.str += padd(date.getMonth() + 1, token == "MM");
                break;
            case "yyyy":
                ret.str += date.getFullYear();
                break;
            case "hh":
            case "h":
                hour = date.getHours() % 12;
                ret.str += padd(hour == 0 ? 12 : hour, token == "hh");
                break;
            case "HH":
            case "H":
                ret.str += padd(date.getHours(), token == "HH");
                break;
            case "mm":
            case "m":
               ret.str += padd(date.getMinutes(), token == "mm");
                break;
            case "tt":
               ret.str += date.getHours() < 12 ? dtf.AMDesignator : dtf.PMDesignator;
        }
    }
    return ret.str;
};
$Date.format = function(date, format) {
    return $Date._toFormattedString(date, format, $CultureInfo.InvariantCulture);
};
$Date.localeFormat = function(date, format) {
    return $Date._toFormattedString(date, format, $CultureInfo.CurrentCulture);
};

$registerNamespace('Sys.Serialization');

var $Serializer = Sys.Serialization.JavaScriptSerializer = function() {};

$Serializer.serialize = function(object) {
    var i, s = "";
    switch (typeof object) {
        case 'object':
            if(!object) s += 'null';
            else if (object.constructor == Array) {
                s += '[';
                for (i = 0; i < object.length; ++i) {
                    if (i > 0) s += ',';
                    s += $Serializer.serialize(object[i]);
                }
                s += ']';
            }
            else if (object.constructor == Date) {
                s += '"\\/Date(' +  object.getTime() + ')\\/"';
            }
            else {
                s += '{';
                var needComma = false;
                for (var name in object) {
                    if (name && name.charAt(0) != '$') {
                        var value = object[name], valueType = typeof value;
                        if (valueType != 'undefined' && valueType != 'function') {
                            if (needComma) s += ',';
                            s += $Serializer.serialize(name) + ':' + $Serializer.serialize(value);
                            needComma = true;
                        }
                    }
                }
                s += '}';
            }
            break;

        case 'string':
            s += '"';

            var escapeable = ['\b', '\f', '\n', '\r', '\t'], escaped = ['\\b', '\\f', '\\n', '\\r', '\\t'];
            for (i = 0; i < object.length; ++i) {
                var curChar = object.charAt(i);
                if (curChar >= ' ') {
                    if (curChar == '\\' || curChar == '"') s += '\\';
                    s += curChar;
                }
                else {
                    var escapeIndex = $.Array.indexOf(escapeable, curChar), charCode = curChar.charCodeAt();
                    
                    if(escapeIndex >= 0)
                        s+= escaped[escapeIndex];
                    else
                        s += '\\u00' + (charCode < 16 ? '0' : '') + charCode.toString(16);
                }
            }
            s += '"';
            break;

        default:
            s += object.toString();
            break;
    }
    
    return s;
};
$Serializer.deserialize = function(data) {                                                   
    return eval('(' + data.replace(new RegExp('(^|[^\\\\])\\"\\\\/Date\\((-?[0-9]+)\\)\\\\/\\"', 'g'), "$1new Date($2)") + ')');
};

$registerNamespace('Sys.Net');

var $ScriptBlockExecutor = Sys.Net.ScriptBlockWebRequestExecutor = function() {
    this._webRequest = null;
    this._scriptElement = null;
    this._responseDataVariable = null;
    this._onLoad$ = $createDelegate(this, this._onLoad);
    this._statusCode = null;
};
$ScriptBlockExecutor.prototype = {
    get_webRequest: function() {
        return this._webRequest;
    },
    _set_webRequest: function (value) {
        this._webRequest = value;
    },
    get_responseAvailable: function() {
        return typeof this.get_responseData() != "undefined";
    },
    get_responseData: function () {
        return $ScriptBlockExecutor[this._responseDataVariable];
    },
    get_statusCode: function() {
        return this._statusCode;
    },
    executeRequest: function() {        
        var scriptElement = this._scriptElement = document.createElement("script");
        
        $addHandler(scriptElement, $Browser.agent != $Browser.InternetExplorer ? 'load' : 'readystatechange', this._onLoad$);
        
        this._responseDataVariable = "responseData" + (++$ScriptBlockExecutor.callIndex);
        var url = this._webRequest.getResolvedUrl();
        url += (url.indexOf('?') == -1 ? "?" : "&") + "json=" + $name + ".Sys.Net.ScriptBlockWebRequestExecutor." + this._responseDataVariable;
        scriptElement.type = "text/javascript";
        scriptElement.src = url;
        document.body.appendChild(scriptElement);
    },
    _onLoad : function() {
        if(this.get_responseAvailable()) this._completeRequest(200);
    },
    _completeRequest : function(statusCode) {
        var scriptElement = this._scriptElement;
        this._statusCode = statusCode;
        if(scriptElement) {
            $removeHandler(scriptElement, $Browser.agent != $Browser.InternetExplorer ? 'load' : 'readystatechange', this._onLoad$);
            document.body.removeChild(scriptElement);
            this._scriptElement = null;
        }
        this._webRequest.completed($EventArgs.Empty);
    }
};

$ScriptBlockExecutor.callIndex = 0;

var $UrlResolver = Sys.Net.UrlResolver = function() { };

$UrlResolver.resolveUrl = function(url) {
    if (!url || !$.baseUrl || url.indexOf('://') != -1 || $.baseUrl.indexOf('://') == -1) return url;
    
    return $.baseUrl.substr(0, $.baseUrl.lastIndexOf('/') + 1) + (url.charAt(0) == '/' ? url.substr(1) : url);
};

var $WebRequest = Sys.Net.WebRequest = function() {
    this._url = "";
    this._userContext = null;
    this._executor = null;
    this._body = null;
    this._headers = { };
    this._httpVerb = null;
};

$WebRequest.prototype = {
    add_completed: function (handler) {
        this._get_eventHandlerList().addHandler("completed", handler);
    },
    remove_completed: function (handler) {
        this._get_eventHandlerList().removeHandler("completed", handler);
    },
    completed: function(eventArgs) {
        handler = this._get_eventHandlerList().getHandler("completed");
        if (handler) handler(this._executor, eventArgs);
    },
    _get_eventHandlerList: function() {
        return this._events || (this._events = new $EventHandlerList());
    },
    get_url: function() {
        return this._url;
    },
    set_url: function (value) {
        this._url = value;
    },
    get_userContext: function() {
        return this._userContext;
    },
    set_userContext: function (value) {
        this._userContext = value;
    },
    get_headers : function() {
        return this._headers;
    },
    get_httpVerb : function() {
        return this._httpVerb || (this._body ? "POST" : "GET");
    },
    set_httpVerb : function(value) {
        this._httpVerb = value;
    },
    get_body : function() {
        return this._body;
    },
    set_body : function(value) {
        this._body = value;
    },
    getResolvedUrl: function() {
        return $UrlResolver.resolveUrl(this._url);
    },
    invoke: function() {
        var executor = this._executor = new ($.baseUrl ? $ScriptBlockExecutor : Sys.Net.XMLHttpExecutor)();
        executor._set_webRequest(this);
        executor.executeRequest();
    }
};

})(CF, "CF");
if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();