(function(window,Sys)
{
    var obj,
        getCreate,
        ajaxPath;
    if(!Sys || !Sys.loader)
    {
        var merge = function(target)
            {
                return target = target || {}, foreach(arguments,function(o)
                {
                    o && forIn(o,function(v,n)
                    {
                        target[n] = v
                    })
                },1), target
            },
            forIn = function(obj,callback)
            {
                for(var x in obj)
                    callback(obj[x],x)
            },
            foreach = function(arr,callback,start)
            {
                var cancelled,
                    i,
                    l;
                if(arr)
                    for(arr = arr instanceof Array || typeof arr.length == "number" && (typeof arr.callee == "function" || arr.item && typeof arr.nodeType == "undefined" && !arr.addEventListener && !arr.attachEvent) ? arr : [arr], i = start || 0, l = arr.length; i < l; i++)
                        if(callback(arr[i],i))
                        {
                            cancelled = !0;
                            break
                        }
                return!cancelled
            },
            callIf = function(obj,name,args)
            {
                var fn = obj[name],
                    exists = typeof fn == "function";
                return exists && fn.call(obj,args), exists
            };
        function append(target)
        {
            return target = target || {}, foreach(arguments,function(o)
            {
                o && forIn(o,function(v,n)
                {
                    typeof target[n] == "undefined" && (target[n] = v)
                })
            },1), target
        }
        var attachEvent = !!document.attachEvent,
            notLoading = 0,
            loading = 1,
            loadingCo = 2,
            loaded = 3,
            autoToken = {};
        function foreachScriptInfo(arr,callback)
        {
            var cancelled,
                i,
                l;
            if(arr)
                for(i = 0, l = arr.length; i < l; i++)
                    if(callback(getScriptInfo(arr[i])))
                    {
                        cancelled = !0;
                        break
                    }
            return!cancelled
        }
        function toIndex(arr)
        {
            var obj = {};
            return foreach(arr,function(name)
            {
                obj[name] = !0
            }), obj
        }
        function contains(source,item)
        {
            for(var i = 0,
                l = source.length; i < l; i++)
                if(source[i] === item)
                    return!0;
            return!1
        }
        function getCompositeDependencies(composite,executionDependencies)
        {
            var dependencies = [];
            return foreachScriptInfo(composite.contains,function(scriptInfo)
            {
                foreach(lazyget(scriptInfo,executionDependencies ? "executionDependencies" : "dependencies"),function(name)
                {
                    composite._contains[name] || dependencies.push(name)
                })
            }), dependencies
        }
        function getDependencies(scriptInfo,executionDependencies)
        {
            var dependencies,
                composite;
            return scriptInfo.contains ? dependencies = getCompositeDependencies(scriptInfo,executionDependencies) : (composite = getComposite(scriptInfo), dependencies = composite ? getCompositeDependencies(composite,executionDependencies) : lazyget(scriptInfo,executionDependencies ? "executionDependencies" : "dependencies")), dependencies
        }
        function requireParents(scriptInfo)
        {
            forIn(scriptInfo._parents,function(parentInfo)
            {
                forIn(parentInfo._composites,function(composite)
                {
                    requireScript(composite,null,null,!0)
                }), requireScript(parentInfo,null,null,!0)
            })
        }
        function getScriptInfo(name)
        {
            return resolveScriptInfo(name) || (Sys.scripts[name] = {
                name:name
            })
        }
        function requireScript(scriptInfo,callback,session,readOnly)
        {
            return Sys.loader._requireScript(scriptInfo,callback,session,readOnly)
        }
        function requireAll(scriptInfos,callback,session,readOnly)
        {
            var waiting;
            return foreach(scriptInfos,function(dependency)
            {
                dependency = resolveScriptInfo(dependency), waiting |= requireScript(dependency,callback,session,readOnly)
            }), waiting
        }
        function resolveScriptInfo(nameOrScriptInfo,onlyScripts)
        {
            var info = typeof nameOrScriptInfo == "string" ? Sys.scripts[nameOrScriptInfo] || Sys.composites[nameOrScriptInfo] || !onlyScripts && (lazyget(Sys.components[nameOrScriptInfo],"script") || lazyget(Sys.plugins[nameOrScriptInfo],"script")) : nameOrScriptInfo ? nameOrScriptInfo.script || nameOrScriptInfo : null;
            return info && !info._isScript && (info = null), info
        }
        function state(scriptInfo,newState)
        {
            var ret = (scriptInfo._state = newState || scriptInfo._state) || 0;
            return newState && foreachScriptInfo(scriptInfo.contains,function(scriptInfo)
            {
                state(scriptInfo,newState)
            }), ret
        }
        function getComposite(scriptInfo)
        {
            return scriptInfo._composite
        }
        function isLoaded(scriptInfo)
        {
            return!scriptInfo || state(scriptInfo) > loadingCo
        }
        function getAndDelete(obj,field)
        {
            var r = obj[field];
            return delete obj[field], r
        }
        function foreachCall(obj,field,args)
        {
            foreach(getAndDelete(obj,field),function(callback)
            {
                callback.apply(null,args || [])
            })
        }
        function lazyget(obj,name,value)
        {
            return obj ? obj[name] = obj[name] || value : value
        }
        function lazypush(obj,name,value)
        {
            lazyget(obj,name,[]).push(value)
        }
        function lazyset(obj,name,key,value)
        {
            lazyget(obj,name,{})[key] = value
        }
        function all(tag,element)
        {
            return(element || document).getElementsByTagName(tag)
        }
        function createElement(tag)
        {
            return document.createElement(tag)
        }
        function listenOnce(target,name,ieName,callback,isReadyState,isScript)
        {
            function onEvent()
            {
                attachEvent && isReadyState && !/loaded|complete/.test(target.readyState) || (attachEvent ? target.detachEvent(ieName || "on" + name,onEvent) : (target.removeEventListener(name,onEvent,!1), isScript && target.removeEventListener("error",onEvent,!1)), callback.apply(target), target = null)
            }
            attachEvent ? target.attachEvent(ieName || "on" + name,onEvent) : (target.addEventListener && target.addEventListener(name,onEvent,!1), isScript && target.addEventListener("error",onEvent,!1))
        }
        function raiseDomReady()
        {
            Sys._domReady && Sys._2Pass(getAndDelete(Sys,"_domReadyQueue"))
        }
        function raiseOnReady()
        {
            var ready = Sys._ready;
            ready || !Sys._domReady || Sys.loader && Sys.loader._loading || (Sys._ready = ready = !0), ready && Sys._2Pass(getAndDelete(Sys,"_readyQueue"))
        }
        window.Sys = Sys = append(Sys,{
            version:[3,0,31106,0],
            __namespace:!0,
            debug:!0,
            scripts:{},
            activateDom:!0,
            composites:{},
            components:{},
            plugins:{},
            create:{},
            converters:{},
            _domLoaded:function()
            {
                function domReady()
                {
                    if(!Sys._domReady)
                    {
                        Sys._domReady = !0;
                        var autoRequire = Sys._autoRequire;
                        autoRequire && Sys.require(autoRequire,function()
                        {
                            Sys._autoRequire = null, foreachCall(Sys,"_autoQueue")
                        },autoToken), raiseDomReady(), raiseOnReady()
                    }
                }
                var check,
                    timeout,
                    er,
                    el;
                if(Sys._domChecked)
                    return;
                Sys._domChecked = !0, listenOnce(window,"load",null,domReady), attachEvent ? window == window.top && document.documentElement.doScroll ? (el = createElement("div"), check = function()
                {
                    try
                    {
                        el.doScroll("left")
                    }
                    catch(er)
                    {
                        timeout = window.setTimeout(check,0);
                        return
                    }
                    el = null, domReady()
                }, check()) : listenOnce(document,null,"onreadystatechange",domReady,!0) : document.addEventListener && listenOnce(document,"DOMContentLoaded",null,domReady)
            },
            _getById:function(found,id,single,includeSelf,element,filter)
            {
                if(element)
                    includeSelf && element.id === id ? found.push(element) : filter || foreach(all("*",element),function(element)
                    {
                        if(element.id === id)
                            return found.push(element), !0
                    });
                else
                {
                    var e = document.getElementById(id);
                    e && found.push(e)
                }
                return found.length
            },
            _getByClass:function(found,targetClass,single,includeSelf,element,filter)
            {
                function pushIfMatch(element)
                {
                    var ret,
                        className = element.className;
                    return!className || className !== targetClass && className.indexOf(" " + targetClass) < 0 && className.indexOf(targetClass + " ") < 0 || (found.push(element), ret = !0), ret
                }
                var i,
                    l,
                    nodes,
                    finder;
                if(includeSelf && pushIfMatch(element) && single)
                    return!0;
                if(!filter)
                {
                    element = element || document, finder = element.querySelectorAll || element.getElementsByClassName;
                    if(finder)
                        for(element.querySelectorAll && (targetClass = "." + targetClass), nodes = finder.call(element,targetClass), i = 0, l = nodes.length; i < l; i++)
                        {
                            found.push(nodes[i]);
                            if(single)
                                return!0
                        }
                    else
                        for(nodes = all("*",element), i = 0, l = nodes.length; i < l; i++)
                            if(pushIfMatch(nodes[i]) && single)
                                return!0
                }
            },
            query:function(selector,context)
            {
                return new Sys.ElementSet(selector,context)
            },
            get:function(selector,context)
            {
                return context && typeof context.get == "function" ? context.get(selector) : this._find(selector,context,!0)
            },
            _find:function(selector,context,single,filter)
            {
                var found = [],
                    selectors;
                selectors = typeof selector == "string" ? [selector] : selector;
                var includeSelf = context instanceof Array,
                    simpleNonTag = /^([\$#\.])((\w|[$:\.\-])+)$/,
                    tag = /^((\w+)|\*)$/;
                return(typeof context == "string" || context instanceof Array) && (context = Sys._find(context)), context instanceof Sys.ElementSet && (context = context.get()), foreach(selectors,function(selector)
                {
                    var match,
                        type,
                        finder,
                        nodes;
                    if(typeof selector != "string")
                        filter ? contains(context,selector) && found.push(selector) : found.push(selector);
                    else
                    {
                        match = simpleNonTag.exec(selector);
                        if(match && match.length === 4)
                            selector = match[2], type = match[1], type === "$" ? Sys._getComponent(found,selector,context) : (finder = type === "#" ? Sys._getById : Sys._getByClass, context ? foreach(context,function(node)
                            {
                                if(node.nodeType === 1)
                                    return finder(found,selector,single,includeSelf,node,filter)
                            }) : finder(found,selector,single));
                        else if(tag.test(selector))
                            if(context instanceof Array)
                                foreach(context,function(node)
                                {
                                    if(node.nodeType === 1)
                                    {
                                        if(includeSelf && (selector === "*" || node.tagName.toLowerCase() === selector))
                                        {
                                            found.push(node);
                                            if(single)
                                                return!0
                                        }
                                        if(!filter)
                                            if(!foreach(all(selector,node),function(node)
                                            {
                                                return found.push(node), single ? !0 : void 0
                                            }))
                                                return!0
                                    }
                                });
                            else
                            {
                                nodes = all(selector,context);
                                if(single)
                                    return nodes[0] && found.push(nodes[0]), !0;
                                foreach(nodes,function(node)
                                {
                                    found.push(node)
                                })
                            }
                        else
                            window.jQuery && (filter || found.push.apply(found,jQuery(selector,context).get()), includeSelf && found.push.apply(found,jQuery(context).filter(selector).get()))
                    }
                }), found.length ? single ? found[0] || null : found : null
            },
            onDomReady:function(callback)
            {
                lazypush(this,"_domReadyQueue",callback), raiseDomReady()
            },
            onReady:function(callback)
            {
                lazypush(this,"_readyQueue",callback), raiseOnReady()
            },
            _set:function(instance,properties)
            {
                forIn(properties,function(value,field)
                {
                    callIf(instance,"add_" + field,value) || callIf(instance,"set_" + field,value) || (instance[field] = value)
                })
            },
            require:function(features,completedCallback,userContext)
            {
                function raiseCallback()
                {
                    if(completedCallback)
                        if(Sys._autoRequire && userContext !== autoToken)
                            lazypush(Sys,"_autoQueue",raiseCallback);
                        else
                            Sys.onDomReady(function()
                            {
                                completedCallback(features,userContext)
                            })
                }
                function allLoaded()
                {
                    loaded || iterating || iteration() || (loaded = !0, raiseCallback()), raiseOnReady()
                }
                function iteration()
                {
                    var resolvedScripts,
                        waiting;
                    return iterating = !0, resolvedScripts = [], foreach(features,function(feature)
                    {
                        feature = resolveScriptInfo(feature);
                        if(feature)
                        {
                            var contains = feature.contains;
                            contains ? foreachScriptInfo(contains,function(scriptInfo)
                            {
                                resolvedScripts.push(scriptInfo)
                            }) : resolvedScripts.push(feature)
                        }
                    }), Sys.loader.combine && Sys.loader._findComposites(resolvedScripts), waiting = requireAll(resolvedScripts,allLoaded,session), iterating = !1, waiting
                }
                var session = Sys.loader._session++,
                    iterating,
                    loaded;
                allLoaded()
            },
            loadScripts:function(scriptUrls,completedCallback,userContext)
            {
                this.loader._loadScripts(scriptUrls,completedCallback,userContext)
            },
            loader:{
                __class:!0,
                combine:!0,
                basePath:"",
                _loading:0,
                _session:0,
                _init:function()
                {
                    var scripts = all("script"),
                        selfUrl = scripts.length ? scripts[scripts.length - 1].src : null,
                        i,
                        list,
                        args;
                    selfUrl && (this.basePath = selfUrl.slice(0,selfUrl.lastIndexOf("/")), i = selfUrl.lastIndexOf("#"), i !== -1 && (args = selfUrl.substr(i + 1).split("&"), foreach(args,function(pair)
                    {
                        var parts = pair.split("="),
                            name = parts[0],
                            value = parts[1];
                        name === "require" && (list = value.split(","))
                    })), Sys._autoRequire = list)
                },
                _loadSrc:function(src,callback)
                {
                    var script = merge(createElement("script"),{
                            type:"text/javascript",
                            src:src
                        }),
                        loaded = lazyget(this,"_loadedScripts",{}),
                        ls;
                    foreach(all("script"),function(script)
                    {
                        var src = script.src;
                        src && !loaded[src] && (loaded[src] = [])
                    }), ls = loaded[src], ls ? callback && ls.push(callback) : (listenOnce(script,"load","onreadystatechange",function()
                    {
                        foreach(ls,function(callback)
                        {
                            callback()
                        }), loaded[src] = null
                    },!0,!0), this._loading++, loaded[src] = ls = callback ? [callback] : [], all("head")[0].appendChild(script))
                },
                _load:function(scriptInfo,callback,session)
                {
                    var waiting,
                        notifyList,
                        key;
                    return isLoaded(scriptInfo) ? callback() : (waiting = !0, notifyList = lazyget(scriptInfo,"_notify",[]), key = "session" + session, notifyList[key] || (notifyList[key] = !0, notifyList.push(callback)), state(scriptInfo) < loading && (state(scriptInfo,loading), this._loadSrc(this._getUrl(scriptInfo),this._getHandler(scriptInfo)))), waiting
                },
                _getUrl:function(scriptInfo)
                {
                    var debug = Sys.debug,
                        name = scriptInfo.name,
                        path = (debug ? scriptInfo.debugUrl || scriptInfo.releaseUrl : scriptInfo.releaseUrl).replace(/\{0\}/g,name) || "",
                        basePath,
                        hasSlash;
                    return path.substr(0,2) === "%/" && (basePath = this.basePath, hasSlash = basePath.charAt(basePath.length - 1) === "/", path = basePath + (hasSlash ? "" : "/") + path.substr(2)), path
                },
                _getHandler:function(scriptInfo)
                {
                    return function()
                    {
                        Sys.loader._loading--, state(scriptInfo) < loadingCo && state(scriptInfo,loadingCo), foreachCall(scriptInfo,"_notify"), foreachScriptInfo(scriptInfo.contains,function(scriptInfo)
                        {
                            foreachCall(scriptInfo,"_notify")
                        })
                    }
                },
                _findComposites:function(scripts)
                {
                    function visit(script)
                    {
                        script = resolveScriptInfo(script);
                        var currentState = state(script);
                        currentState < loading && !getComposite(script) && (scriptSet[script.name] = script, foundAny = !0, foreach(script.dependencies,visit)), currentState < loaded && foreach(script.executionDependencies,visit)
                    }
                    var scriptSet = {},
                        compositeMapping = {},
                        foundAny;
                    foreach(scripts,visit), foundAny && (forIn(Sys.composites,function(composite)
                    {
                        if(foreachScriptInfo(composite.contains,function(contained)
                        {
                            if(!scriptSet[contained.name])
                                return!0
                        }))
                        {
                            var offsets = {},
                                offsetCount = 0;
                            foreach(composite.contains,function(name)
                            {
                                var otherCandidate = compositeMapping[name];
                                otherCandidate && !offsets[otherCandidate.name] && (offsets[otherCandidate.name] = otherCandidate, offsetCount += otherCandidate.contains.length - 1)
                            }), composite.contains.length - 1 > offsetCount && (forIn(offsets,function(offset)
                            {
                                foreach(offset.contains,function(name)
                                {
                                    delete compositeMapping[name]
                                })
                            }), foreach(composite.contains,function(name)
                            {
                                compositeMapping[name] = composite
                            }))
                        }
                    }), forIn(compositeMapping,function(composite,name)
                    {
                        Sys.scripts[name]._composite = composite
                    }))
                },
                _loadScripts:function(scriptUrls,completedCallback,userContext)
                {
                    function scriptLoaded(first)
                    {
                        first || Sys.loader._loading--, ++index < scriptUrls.length ? Sys.loader._loadSrc(scriptUrls[index],scriptLoaded) : (completedCallback && completedCallback(scriptUrls,userContext), raiseOnReady())
                    }
                    var index = -1,
                        loaded = lazyget(this,"_loadedScripts",{});
                    scriptUrls = scriptUrls instanceof Array ? Array.apply(null,scriptUrls) : [scriptUrls], scriptLoaded(!0)
                },
                _requireScript:function(scriptInfo,callback,session,readOnly)
                {
                    var waiting,
                        waitForDeps,
                        waitForDepsCo,
                        contains;
                    return isLoaded(scriptInfo) || (waitForDeps = requireAll(getDependencies(scriptInfo),callback,session,readOnly), waitForDepsCo = requireAll(getDependencies(scriptInfo,!0),callback,session,readOnly), waitForDeps || waitForDepsCo || state(scriptInfo) !== loadingCo ? readOnly || waitForDeps || this._load(getComposite(scriptInfo) || scriptInfo,callback,session) : (state(scriptInfo,loaded), foreachCall(scriptInfo,"_callback"), readOnly && (contains = scriptInfo.contains, contains ? foreachScriptInfo(contains,function(scriptInfo)
                    {
                        requireParents(scriptInfo)
                    }) : requireParents(getScriptInfo(scriptInfo)))), waiting |= waitForDeps || waitForDepsCo), waiting || !isLoaded(scriptInfo)
                },
                _registerParents:function(scriptInfo)
                {
                    function register(dependency)
                    {
                        var depInfo = getScriptInfo(dependency);
                        lazyset(depInfo,"_parents",scriptInfo.name,scriptInfo)
                    }
                    foreach(scriptInfo.dependencies,register), foreach(scriptInfo.executionDependencies,register)
                },
                defineScript:function(scriptInfo)
                {
                    var scripts = Sys.scripts,
                        name = scriptInfo.name,
                        contains = scriptInfo.contains,
                        loader = this,
                        composites,
                        isBehavior;
                    if(contains)
                        composites = Sys.composites, composites[name] = scriptInfo = merge(composites[name],scriptInfo), scriptInfo._contains = toIndex(contains), foreachScriptInfo(contains,function(contain)
                        {
                            lazyset(contain,"_composites",name,scriptInfo)
                        });
                    else
                    {
                        scriptInfo = scripts[name] = merge(scripts[name],scriptInfo), this._registerParents(scriptInfo);
                        function registerComponent(component)
                        {
                            var name,
                                i;
                            typeof component == "string" ? component = {
                                typeName:component
                            } : name = component.name, name || (name = component.typeName, i = name.lastIndexOf("."), i < 0 || (name = name.substr(i + 1)), name = name.substr(0,1).toLowerCase() + name.substr(1), component.name = name), component._isBehavior = isBehavior, component.script = scriptInfo;
                            var components = Sys.components,
                                entry = components[name] = merge(components[name],component),
                                fn = Sys._getCreate(component),
                                target = isBehavior ? Sys.ElementSet.prototype : Sys.create;
                            target[name] = target[name] || fn
                        }
                        foreach(scriptInfo.components,registerComponent), isBehavior = !0, foreach(scriptInfo.behaviors,registerComponent), foreach(scriptInfo.plugins,function(plugin)
                        {
                            var name = plugin.name,
                                fnName = plugin.functionName || name,
                                plugins = Sys.plugins,
                                target;
                            plugin.script = scriptInfo, plugins[name] = merge(plugins[name],plugin), target = plugin.global ? Sys : plugin.dom ? Sys.ElementSet.prototype : plugin.components ? Sys.ComponentSet.prototype : null, target && (target[fnName] = target[fnName] || Sys._getCreate(plugin,!0))
                        })
                    }
                    scriptInfo.isLoaded && (scriptInfo._state = loaded), scriptInfo._isScript = !0
                },
                defineScripts:function(defaultScriptInfo,scriptInfos)
                {
                    foreach(scriptInfos,function(scriptInfo)
                    {
                        Sys.loader.defineScript(merge(null,defaultScriptInfo,scriptInfo))
                    })
                },
                registerScript:function(name,executionDependencies,executionCallback)
                {
                    var scriptInfo = getScriptInfo(name),
                        existingList,
                        existing;
                    scriptInfo._callback = executionCallback, existingList = lazyget(scriptInfo,"executionDependencies",[]), existing = toIndex(existingList), foreach(executionDependencies,function(executionDependency)
                    {
                        existing[executionDependency] || existingList.push(executionDependency)
                    }), this._registerParents(scriptInfo), state(scriptInfo,loadingCo), requireScript(scriptInfo,null,null,!0)
                }
            }
        }), Sys._getComponent = Sys._getComponent || function(){}, Sys._2Pass = Sys._2Pass || function(callback)
        {
            foreach(callback,function(c)
            {
                c()
            })
        }, Sys.ElementSet || (obj = Sys.ElementSet = function(selector,context)
        {
            this._elements = typeof context == "object" && typeof context.query == "function" ? context.query(selector).get() : Sys._find(selector,context) || []
        }, obj.prototype = {
            __class:!0,
            components:function(type,index)
            {
                var elementSet = new Sys.ElementSet(this.get());
                return new Sys.ComponentSet(elementSet,type,index)
            },
            component:function(type,index)
            {
                return this.components(type,index).get(0)
            },
            each:function(callback)
            {
                for(var elements = this._elements,
                    i = 0,
                    l = elements.length; i < l; i++)
                    if(callback.call(elements[i],i) === !1)
                        break;
                return this
            },
            get:function(index)
            {
                var elements = this._elements;
                return typeof index == "undefined" ? Array.apply(null,elements) : elements[index] || null
            },
            find:function(selector)
            {
                return new Sys.ElementSet(selector,this)
            },
            filter:function(selector)
            {
                return new Sys.ElementSet(Sys._find(selector,this._elements,!1,!0))
            }
        }), Sys.ComponentSet || (obj = Sys.ComponentSet = function(elementSet,query,index)
        {
            this._elementSet = elementSet || (elementSet = new Sys.ElementSet), this._components = this._execute(elementSet,query,index)
        }, obj.prototype = {
            __class:!0,
            setProperties:function(properties)
            {
                return this.each(function()
                {
                    Sys._set(this,properties)
                })
            },
            get:function(index)
            {
                var components = this._components;
                return typeof index == "undefined" ? Array.apply(null,components) : components[index || 0] || null
            },
            each:function(callback)
            {
                return foreach(this._components,function(c,i)
                {
                    if(callback.call(c,i) === !1)
                        return!0
                }), this
            },
            elements:function()
            {
                return this._elementSet
            },
            _execute:function(elementSet,query,index)
            {
                function match(c)
                {
                    var ctor;
                    return c instanceof query || (ctor = c.constructor) && (ctor === query || ctor.inheritsFrom && ctor.inheritsFrom(query) || ctor.implementsInterface && ctor.implementsInterface(query))
                }
                var components = [];
                return query instanceof Array ? components.push.apply(components,query) : elementSet.each(function()
                {
                    var c = this.control;
                    c && (!query || match(c)) && components.push(c), foreach(this._behaviors,function(b)
                    {
                        (!query || match(b)) && components.push(b)
                    })
                }), typeof index != "undefined" && (components = components[index] ? [components[index]] : []), components
            }
        }), obj = null, getCreate = function(options,isPlugin)
        {
            var body = [],
                arglist = [],
                type = options.type,
                typeName = options.typeName || (type ? type.getName() : ""),
                isBehavior = options._isBehavior,
                description = options && options.description || type && "Creates an instance of the type '" + typeName + "' and sets the given properties." || "",
                returnType,
                fn;
            return body.push("/// <summary>",description,"</summary>\n"), foreach(options && options.parameters,function(parameter)
            {
                var name = parameter,
                    type = "",
                    desc = "";
                typeof parameter != "string" && (name = parameter.name, type = parameter.type || "", desc = parameter.description || ""), arglist.push(name), body.push('/// <param name="',name,'"'), type && body.push(' type="',type,'"'), body.push(">",desc,"</param>\n")
            }), isPlugin ? returnType = options.returnType : (arglist.push("properties"), body.push('/// <param name="properties" type="Object" mayBeNull="true" optional="true">Additional properties to set on the component.</param>\n'), returnType = isBehavior ? "Sys.ComponentSet" : typeName), returnType && body.push('/// <returns type="',returnType,'" />\n'), body.push("throw new Error(\"The '",options.name,"' plugin requires Sys.scripts.",options.script.name,' to be loaded with a call to Sys.require() first.");\n'), arglist.push(body.join("")), fn = Function.apply(null,arglist), isPlugin || (fn._component = options), fn._slmock = !0, fn
        }, Sys._getCreate = Sys._getCreate || getCreate, obj = Sys.loader, obj.defineScripts({
            releaseUrl:"%/MicrosoftAjax{0}.js",
            debugUrl:"%/MicrosoftAjax{0}.debug.js",
            executionDependencies:["Core"]
        },[{
            name:"Core",
            executionDependencies:null,
            isLoaded:!!window.Type
        },{
            name:"ComponentModel",
            plugins:[{
                name:"setCommand",
                dom:!0,
                description:"Causes a DOM element to raise a bubble event when clicked.",
                parameters:[{
                    name:"commandName",
                    description:"The name of the command to raise."
                },{
                    name:"commandArgument",
                    description:"Optional command argument."
                },{
                    name:"commandTarget",
                    description:"DOM element from which the command should start bubbling up."
                }]
            },{
                name:"addHandler",
                dom:!0,
                description:"A cross-browser way to add a DOM event handler to an element.",
                parameters:[{
                    name:"eventName",
                    type:"String",
                    description:"The name of the event. Do not include the 'on' prefix, for example, 'click' instead of 'onclick'."
                },{
                    name:"handler",
                    type:"Function",
                    description:"The event handler to add."
                },{
                    name:"autoRemove",
                    type:"Boolean",
                    description:"Whether the handler should be removed automatically when the element is disposed of, such as when an UpdatePanel refreshes, or Sys.Application.disposeElement is called."
                }]
            },{
                name:"removeHandler",
                dom:!0,
                description:"A cross-browser way to remove a DOM event handler from an element.",
                parameters:[{
                    name:"eventName",
                    type:"String",
                    description:"The name of the event. Do not include the 'on' prefix, for example, 'click' instead of 'onclick'."
                },{
                    name:"handler",
                    type:"Function",
                    description:"The event handler to remove."
                }]
            },{
                name:"addHandlers",
                dom:!0,
                description:"Adds a list of event handlers to an element. If a handlerOwner is specified, delegates are created with each of the handlers.",
                parameters:[{
                    name:"events",
                    type:"Object",
                    description:"A dictionary of event handlers."
                },{
                    name:"handlerOwner",
                    description:"The owner of the event handlers that will be the this pointer for the delegates that will be created from the handlers."
                },{
                    name:"autoRemove",
                    type:"Boolean",
                    description:"Whether the handler should be removed automatically when the element is disposed of, such as when an UpdatePanel refreshes, or Sys.Application.disposeElement is called."
                }]
            },{
                name:"clearHandlers",
                dom:!0,
                description:"Clears all the event handlers that were added to the element or array of elements."
            }],
            isLoaded:!!Sys.Component
        },{
            name:"History",
            executionDependencies:["ComponentModel","Serialization"],
            isLoaded:!!(Sys.Application && Sys.Application.get_stateString)
        },{
            name:"Serialization",
            isLoaded:!!Sys.Serialization
        },{
            name:"Network",
            executionDependencies:["Serialization"],
            isLoaded:!!(Sys.Net && Sys.Net.WebRequest)
        },{
            name:"WebServices",
            executionDependencies:["Network"],
            isLoaded:!!(Sys.Net && Sys.Net.WebServiceProxy)
        },{
            name:"ApplicationServices",
            executionDependencies:["WebServices"],
            isLoaded:!!(Sys.Services && Sys.Services.RoleService && Sys.Services.RoleService.get_path)
        },{
            name:"Globalization",
            isLoaded:!!Number._parse
        },{
            name:"OpenData",
            executionDependencies:["DataContext"],
            components:["Sys.Data.OpenDataContext",{
                typeName:"Sys.Data.OpenDataServiceProxy",
                parameters:[{
                    name:"serviceUri",
                    type:"String"
                }]
            }],
            isLoaded:!!(Sys.Data && Sys.Data.OpenDataServiceProxy)
        },{
            name:"DataContext",
            executionDependencies:["ComponentModel","Serialization","WebServices"],
            components:["Sys.Data.DataContext"],
            isLoaded:!!(Sys.Data && Sys.Data.DataContext)
        },{
            name:"Templates",
            executionDependencies:["ComponentModel","Serialization"],
            behaviors:["Sys.UI.DataView"],
            plugins:[{
                name:"binding",
                global:!0,
                parameters:["target",{
                    name:"property",
                    type:"String"
                },"source",{
                    name:"path",
                    type:"String"
                },"options"]
            },{
                name:"binding",
                dom:!0,
                parameters:[{
                    name:"property",
                    type:"String"
                },"source",{
                    name:"path",
                    type:"String"
                },"options"]
            },{
                name:"binding",
                components:!0,
                parameters:[{
                    name:"property",
                    type:"String"
                },"source",{
                    name:"path",
                    type:"String"
                },"options"]
            },{
                name:"activateElements",
                dom:!0,
                parameters:[{
                    name:"bindingContext",
                    description:"The binding context."
                },{
                    name:"recursive",
                    type:"Boolean",
                    description:"Specifies whether processing should occur recursively."
                }]
            }],
            isLoaded:!!(Sys.UI && Sys.UI.Template)
        },{
            name:"MicrosoftAjax",
            releaseUrl:"%/MicrosoftAjax.js",
            debugUrl:"%/MicrosoftAjax.debug.js",
            executionDependencies:null,
            contains:["Core","ComponentModel","History","Serialization","Network","WebServices","Globalization"]
        }]), ajaxPath = (window.location.protocol === "https:" ? "https" : "http") + "://ajax.microsoft.com/ajax/", obj.defineScripts(null,[{
            name:"jQuery",
            releaseUrl:ajaxPath + "jquery/jquery-1.4.1.min.js",
            debugUrl:ajaxPath + "jquery/jquery-1.4.1.js",
            isLoaded:!!window.jQuery
        },{
            name:"jQueryValidate",
            releaseUrl:ajaxPath + "jquery.validate/1.6/jquery.validate.min.js",
            debugUrl:ajaxPath + "jquery.validate/1.6/jquery.validate.js",
            dependencies:["jQuery"],
            isLoaded:!!(window.jQuery && jQuery.fn.validate)
        }]), obj._init(), window.Type || (window.Type = Function, Type.registerNamespace = Type.registerNamespace || function(namespacePath)
        {
            lazypush(Sys,"_ns",namespacePath);
            var rootObject = window;
            foreach(namespacePath.split("."),function(part)
            {
                rootObject = rootObject[part] = rootObject[part] || {}
            }), rootObject = null
        }), Sys._domLoaded()
    }
})(window,window.Sys);