var base2 = {
    name: "base2",
    version: "1.0",
    exports: "Base,Package,Abstract,Module,Enumerable,Map,Collection,RegGrp,Undefined,Null,This,True,False,assignID,detect,global",
    namespace: ""
};
new function(_no_shrink_) {
    var Undefined = K(),
    Null = K(null),
    True = K(true),
    False = K(false),
    This = function() {
        return this
    };
    var global = This();
    var base2 = global.base2;
    var _FORMAT = /%([1-9])/g;
    var _LTRIM = /^\s\s*/;
    var _RTRIM = /\s\s*$/;
    var _RESCAPE = /([\/()[\]{}|*+-.,^$?\\])/g;
    var _BASE = /try/.test(detect) ? /\bbase\b/: /.*/;
    var _HIDDEN = ["constructor", "toString", "valueOf"];
    var _MSIE_NATIVE_FUNCTION = detect("(jscript)") ? new RegExp("^" + rescape(isNaN).replace(/isNaN/, "\\w+") + "$"): {
        test: False
    };
    var _counter = 1;
    var _slice = Array.prototype.slice;
    _Function_forEach();
    function assignID(object) {
        if ( ! object.base2ID) {
            object.base2ID = "b2_" + _counter ++ 
        }
        return object.base2ID
    }
    var _subclass = function(_instance, _static) {
        base2.__prototyping = this.prototype;
        var _prototype = new this;
        if (_instance) {
            extend(_prototype, _instance)
            }
        delete base2.__prototyping;
        var _constructor = _prototype.constructor;
        function _class() {
            if ( ! base2.__prototyping) {
                if (this.constructor == arguments.callee || this.__constructing) {
                    this.__constructing = true;
                    _constructor.apply(this, arguments);
                    delete this.__constructing
                } else {
                    return extend(arguments[0], _prototype)
                    }
            }
            return this
        }
        _prototype.constructor = _class;
        for (var i in Base) {
            _class[i] = this[i]
            }
        _class.ancestor = this;
        _class.base = Undefined;
        if (_static) {
            extend(_class, _static)
            }
        _class.prototype = _prototype;
        if (_class.init) {
            _class.init()
            }
        _class["#implements"] = [];
        _class["#implemented_by"] = [];
        return _class
    };
    var Base = _subclass.call(Object, {
        constructor: function() {
            if (arguments.length > 0) {
                this.extend(arguments[0])
                }
        },
        base: function() {},
        extend: delegate(extend)
        }, Base = {
        ancestorOf: function(klass) {
            return _ancestorOf(this, klass)
            },
        extend: _subclass,
        forEach: function(object, block, context) {
            _Function_forEach(this, object, block, context)
            },
        implement: function(source) {
            if (typeof source == "function") {
                if (_ancestorOf(Base, source)) {
                    this["#implements"].push(source);
                    source["#implemented_by"].push(this)
                    }
                source = source.prototype
            }
            extend(this.prototype, source);
            return this
        }
    });
    var Package = Base.extend( {
        constructor: function(_private, _public) {
            this.extend(_public);
            if (this.init) {
                this.init()
                }
            if (this.name && this.name != "base2") {
                if ( ! this.parent) {
                    this.parent = base2
                }
                this.parent.addName(this.name, this);
                this.namespace = format("var %1=%2;", this.name, String2.slice(this, 1 ,- 1))
                }
            if (_private) {
                var JSNamespace = base2.JavaScript ? base2.JavaScript.namespace: "";
                _private.imports = Array2.reduce(csv(this.imports), function(namespace, name) {
                    var ns = lookup(name) || lookup("JavaScript." + name);
                    assert(ns, format("Object not found: '%1'.", name), ReferenceError);
                    return namespace += ns.namespace
                }, "var base2=(function(){return this.base2})();" + base2.namespace + JSNamespace) + lang.namespace;
                _private.exports = Array2.reduce(csv(this.exports), function(namespace, name) {
                    var fullName = this.name + "." + name;
                    this.namespace += "var " + name + "=" + fullName + ";";
                    return namespace += "if(!" + fullName + ")" + fullName + "=" + name + ";"
                }, "", this) + "this._label_" + this.name + "();";
                var pkg = this;
                var packageName = String2.slice(this, 1 ,- 1);
                _private["_label_" + this.name] = function() {
                    Package.forEach(pkg, function(object, name) {
                        if (object && object.ancestorOf == Base.ancestorOf) {
                            object.toString = K(format("[%1.%2]", packageName, name));
                            if (object.prototype.toString == Base.prototype.toString) {
                                object.prototype.toString = K(format("[object %1.%2]", packageName, name))
                                }
                        }
                    })
                    }
            }
            function lookup(names) {
                names = names.split(".");
                var value = base2,
                i = 0;
                while (value && names[i] != null) {
                    value = value[names[i ++ ]]
                    }
                return value
            }
        },
        exports: "",
        imports: "",
        name: "",
        namespace: "",
        parent: null,
        addName: function(name, value) {
            if ( ! this[name]) {
                this[name] = value;
                this.exports += "," + name;
                this.namespace += format("var %1=%2.%1;", name, this.name)
                }
        },
        addPackage: function(name) {
            this.addName(name, new Package(null, {
                name: name,
                parent: this
            }))
            },
        toString: function() {
            return format("[%1]", this.parent ? String2.slice(this.parent, 1 ,- 1) + "." + this.name: this.name)
            }
    });
    var Abstract = Base.extend( {
        constructor: function() {
            throw new TypeError("Abstract class cannot be instantiated.")
            }
    });
    var _moduleCount = 0;
    var Module = Abstract.extend(null, {
        namespace: "",
        extend: function(_interface, _static) {
            var module = this.base();
            var index = _moduleCount ++ ;
            module.namespace = "";
            module.partial = this.partial;
            module.toString = K("[base2.Module[" + index + "]]");
            Module[index] = module;
            module.implement(this);
            if (_interface) {
                module.implement(_interface)
                }
            if (_static) {
                extend(module, _static);
                if (module.init) {
                    module.init()
                    }
            }
            return module
        },
        forEach: function(block, context) {
            _Function_forEach(Module, this.prototype, function(method, name) {
                if (typeOf(method) == "function") {
                    block.call(context, this[name], name, this)
                    }
            }, this)
            },
        implement: function(_interface) {
            var module = this;
            var id = module.toString().slice(1 ,- 1);
            if (typeof _interface == "function") {
                if ( ! _ancestorOf(_interface, module)) {
                    this.base(_interface)
                    }
                if (_ancestorOf(Module, _interface)) {
                    for (var name in _interface) {
                        if (module[name] === undefined) {
                            var property = _interface[name];
                            if (typeof property == "function" && property.call && _interface.prototype[name]) {
                                property = _staticModuleMethod(_interface, name)
                                }
                            module[name] = property
                        }
                    }
                    module.namespace += _interface.namespace.replace(/base2\.Module\[\d+\]/g, id)
                    }
            } else {
                extend(module, _interface);
                _extendModule(module, _interface)
                }
            return module
        },
        partial: function() {
            var module = Module.extend();
            var id = module.toString().slice(1 ,- 1);
            module.namespace = this.namespace.replace(/(\w+)=b[^\)]+\)/g, "$1=" + id + ".$1");
            this.forEach(function(method, name) {
                module[name] = partial(bind(method, module))
                });
            return module
        }
    });
    function _extendModule(module, _interface) {
        var proto = module.prototype;
        var id = module.toString().slice(1 ,- 1);
        for (var name in _interface) {
            var property = _interface[name],
            namespace = "";
            if (name.charAt(0) == "@") {
                if (detect(name.slice(1))) {
                    _extendModule(module, property)
                    }
            } else {
                if ( ! proto[name]) {
                    if (name == name.toUpperCase()) {
                        namespace = "var " + name + "=" + id + "." + name + ";"
                    } else {
                        if (typeof property == "function" && property.call) {
                            namespace = "var " + name + "=base2.lang.bind('" + name + "'," + id + ");";
                            proto[name] = _moduleMethod(module, name);
                            proto[name]._module = module
                        }
                    }
                    if (module.namespace.indexOf(namespace) ==- 1) {
                        module.namespace += namespace
                    }
                }
            }
        }
    }
    function _staticModuleMethod(module, name) {
        return function() {
            return module[name].apply(module, arguments)
            }
    }
    function _moduleMethod(module, name) {
        return function() {
            var args = _slice.call(arguments);
            args.unshift(this);
            return module[name].apply(module, args)
            }
    }
    var Enumerable = Module.extend( {
        every: function(object, test, context) {
            var result = true;
            try {
                forEach(object, function(value, key) {
                    result = test.call(context, value, key, object);
                    if ( ! result) {
                        throw StopIteration
                    }
                })
                }
            catch(error) {
                if (error != StopIteration) {
                    throw error
                }
            }
            return !! result
        },
        filter: function(object, test, context) {
            var i = 0;
            return this.reduce(object, function(result, value, key) {
                if (test.call(context, value, key, object)) {
                    result[i ++ ] = value
                }
                return result
            }, [])
            },
        invoke: function(object, method) {
            var args = _slice.call(arguments, 2);
            return this.map(object, (typeof method == "function") ? function(item) {
                return item == null ? undefined: method.apply(item, args)
                }: function(item) {
                return item == null ? undefined: item[method].apply(item, args)
                })
            },
        map: function(object, block, context) {
            var result = [],
            i = 0;
            forEach(object, function(value, key) {
                result[i ++ ] = block.call(context, value, key, object)
                });
            return result
        },
        pluck: function(object, key) {
            return this.map(object, function(item) {
                return item == null ? undefined: item[key]
                })
            },
        reduce: function(object, block, result, context) {
            var initialised = arguments.length > 2;
            forEach(object, function(value, key) {
                if (initialised) {
                    result = block.call(context, result, value, key, object)
                    } else {
                    result = value;
                    initialised = true
                }
            });
            return result
        },
        some: function(object, test, context) {
            return ! this.every(object, not(test), context)
            }
    });
    var _HASH = "#";
    var Map = Base.extend( {
        constructor: function(values) {
            if (values) {
                this.merge(values)
                }
        },
        clear: function() {
            for (var key in this) {
                if (key.indexOf(_HASH) == 0) {
                    delete this[key]
                    }
            }
        },
        copy: function() {
            base2.__prototyping = true;
            var copy = new this.constructor;
            delete base2.__prototyping;
            for (var i in this) {
                if (this[i] !== copy[i]) {
                    copy[i] = this[i]
                    }
            }
            return copy
        },
        forEach: function(block, context) {
            for (var key in this) {
                if (key.indexOf(_HASH) == 0) {
                    block.call(context, this[key], key.slice(1), this)
                    }
            }
        },
        get: function(key) {
            return this[_HASH + key]
            },
        getKeys: function() {
            return this.map(II)
            },
        getValues: function() {
            return this.map(I)
            },
        has: function(key) {
/*@cc_on @*/
            
/*@if (@_jscript_version < 5.5)
    return $Legacy.has(this, _HASH + key);
  @else @*/
            return _HASH + key in this;
/*@end @*/
            
        },
        merge: function(values) {
            var put = flip(this.put);
            forEach(arguments, function(values) {
                forEach(values, put, this)
                }, this);
            return this
        },
        put: function(key, value) {
            this[_HASH + key] = value
        },
        remove: function(key) {
            delete this[_HASH + key]
            },
        size: function() {
            var size = 0;
            for (var key in this) {
                if (key.indexOf(_HASH) == 0) {
                    size ++ 
                }
            }
            return size
        },
        union: function(values) {
            return this.merge.apply(this.copy(), arguments)
            }
    });
    Map.implement(Enumerable);
    Map.prototype.filter = function(test, context) {
        return this.reduce(function(result, value, key) {
            if ( ! test.call(context, value, key, this)) {
                result.remove(key)
                }
            return result
        }, this.copy(), this)
        };
    var _KEYS = "~";
    var Collection = Map.extend( {
        constructor: function(values) {
            this[_KEYS] = new Array2;
            this.base(values)
            },
        add: function(key, item) {
            assert( ! this.has(key), "Duplicate key '" + key + "'.");
            this.put.apply(this, arguments)
            },
        clear: function() {
            this.base();
            this[_KEYS].length = 0
        },
        copy: function() {
            var copy = this.base();
            copy[_KEYS] = this[_KEYS].copy();
            return copy
        },
        forEach: function(block, context) {
            var keys = this[_KEYS];
            var length = keys.length;
            for (var i = 0; i < length; i ++ ) {
                block.call(context, this[_HASH + keys[i]], keys[i], this)
                }
        },
        getAt: function(index) {
            var key = this[_KEYS].item(index);
            return(key === undefined) ? undefined: this[_HASH + key]
            },
        getKeys: function() {
            return this[_KEYS].copy()
            },
        indexOf: function(key) {
            return this[_KEYS].indexOf(String(key))
            },
        insertAt: function(index, key, item) {
            assert(this[_KEYS].item(index) !== undefined, "Index out of bounds.");
            assert( ! this.has(key), "Duplicate key '" + key + "'.");
            this[_KEYS].insertAt(index, String(key));
            this[_HASH + key] = null;
            this.put.apply(this, _slice.call(arguments, 1))
            },
        item: function(keyOrIndex) {
            return this[typeof keyOrIndex == "number" ? "getAt": "get"]
            (keyOrIndex)
            },
        put: function(key, item) {
            if ( ! this.has(key)) {
                this[_KEYS].push(String(key))
                }
            var klass = this.constructor;
            if (klass.Item &&! instanceOf(item, klass.Item)) {
                item = klass.create.apply(klass, arguments)
                }
            this[_HASH + key] = item
        },
        putAt: function(index, item) {
            arguments[0] = this[_KEYS].item(index);
            assert(arguments[0] !== undefined, "Index out of bounds.");
            this.put.apply(this, arguments)
            },
        remove: function(key) {
            if (this.has(key)) {
                this[_KEYS].remove(String(key));
                delete this[_HASH + key]
                }
        },
        removeAt: function(index) {
            var key = this[_KEYS].item(index);
            if (key !== undefined) {
                this[_KEYS].removeAt(index);
                delete this[_HASH + key]
                }
        },
        reverse: function() {
            this[_KEYS].reverse();
            return this
        },
        size: function() {
            return this[_KEYS].length
        },
        slice: function(start, end) {
            var sliced = this.copy();
            if (arguments.length > 0) {
                var keys = this[_KEYS],
                removed = keys;
                sliced[_KEYS] = Array2(_slice.apply(keys, arguments));
                if (sliced[_KEYS].length) {
                    removed = removed.slice(0, start);
                    if (arguments.length > 1) {
                        removed = removed.concat(keys.slice(end))
                        }
                }
                for (var i = 0; i < removed.length; i ++ ) {
                    delete sliced[_HASH + removed[i]]
                    }
            }
            return sliced
        },
        sort: function(compare) {
            if (compare) {
                this[_KEYS].sort(bind(function(key1, key2) {
                    return compare(this[_HASH + key1], this[_HASH + key2], key1, key2)
                    }, this))
                } else {
                this[_KEYS].sort()
                }
            return this
        },
        toString: function() {
            return "(" + (this[_KEYS] || "") + ")"
        }
    }, {
        Item: null,
        create: function(key, item) {
            return this.Item ? new this.Item(key, item): item
        },
        extend: function(_instance, _static) {
            var klass = this.base(_instance);
            klass.create = this.create;
            if (_static) {
                extend(klass, _static)
                }
            if ( ! klass.Item) {
                klass.Item = this.Item
            } else {
                if (typeof klass.Item != "function") {
                    klass.Item = (this.Item || Base).extend(klass.Item)
                    }
            }
            if (klass.init) {
                klass.init()
                }
            return klass
        }
    });
    var _RG_BACK_REF = /\\(\d+)/g,
    _RG_ESCAPE_CHARS = /\\./g,
    _RG_ESCAPE_BRACKETS = /\(\?[:=!]|\[[^\]]+\]/g,
    _RG_BRACKETS = /\(/g,
    _RG_LOOKUP = /\$(\d+)/,
    _RG_LOOKUP_SIMPLE = /^\$\d+$/;
    var RegGrp = Collection.extend( {
        constructor: function(values, ignoreCase) {
            this.base(values);
            this.ignoreCase =!! ignoreCase
        },
        ignoreCase: false,
        exec: function(string, override) {
            string += "";
            var items = this,
            keys = this[_KEYS];
            if ( ! keys.length) {
                return string
            }
            if (override == RegGrp.IGNORE) {
                override = 0
            }
            return string.replace(new RegExp(this, this.ignoreCase ? "gi": "g"), function(match) {
                var item,
                offset = 1,
                i = 0;
                while ((item = items[_HASH + keys[i ++ ]])) {
                    var next = offset + item.length + 1;
                    if (arguments[offset]) {
                        var replacement = override == null ? item.replacement: override;
                        switch(typeof replacement) {
                            case "function": return replacement.apply(items, _slice.call(arguments, offset, next));
                            case "number": return arguments[offset + replacement];
                            default: return replacement
                        }
                    }
                    offset = next
                }
                return match
            })
            },
        insertAt: function(index, expression, replacement) {
            if (instanceOf(expression, RegExp)) {
                arguments[1] = expression.source
            }
            return base(this, arguments)
            },
        test: function(string) {
            return this.exec(string) != string
        },
        toString: function() {
            var offset = 1;
            return "(" + this.map(function(item) {
                var expression = (item + "").replace(_RG_BACK_REF, function(match, index) {
                    return "\\" + (offset + Number(index))
                    });
                offset += item.length + 1;
                return expression
            }).join(")|(") + ")"
        }
    }, {
        IGNORE: "$0",
        init: function() {
            forEach("add,get,has,put,remove".split(","), function(name) {
                _override(this, name, function(expression) {
                    if (instanceOf(expression, RegExp)) {
                        arguments[0] = expression.source
                    }
                    return base(this, arguments)
                    })
                }, this.prototype)
            },
        Item: {
            constructor: function(expression, replacement) {
                if (replacement == null) {
                    replacement = RegGrp.IGNORE
                } else {
                    if (replacement.replacement != null) {
                        replacement = replacement.replacement
                    } else {
                        if (typeof replacement != "function") {
                            replacement = String(replacement)
                            }
                    }
                }
                if (typeof replacement == "string" && _RG_LOOKUP.test(replacement)) {
                    if (_RG_LOOKUP_SIMPLE.test(replacement)) {
                        replacement = parseInt(replacement.slice(1))
                        } else {
                        var Q = '"';
                        replacement = replacement.replace(/\\/g, "\\\\").replace(/"/g, "\\x22").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\$(\d+)/g, Q + "+(arguments[$1]||" + Q + Q + ")+" + Q).replace(/(['"])\1\+(.*)\+\1\1$/, "$1");
                        replacement = new Function("return " + Q + replacement + Q)
                        }
                }
                this.length = RegGrp.count(expression);
                this.replacement = replacement;
                this.toString = K(expression + "")
                },
            length: 0,
            replacement: ""
        },
        count: function(expression) {
            expression = (expression + "").replace(_RG_ESCAPE_CHARS, "").replace(_RG_ESCAPE_BRACKETS, "");
            return match(expression, _RG_BRACKETS).length
        }
    });
    var lang = {
        name: "lang",
        version: base2.version,
        exports: "assert,assertArity,assertType,base,bind,copy,extend,forEach,format,instanceOf,match,pcopy,rescape,trim,typeOf",
        namespace: ""
    };
    function assert(condition, message, ErrorClass) {
        if ( ! condition) {
            throw new(ErrorClass || Error)
            (message || "Assertion failed.")
            }
    }
    function assertArity(args, arity, message) {
        if (arity == null) {
            arity = args.callee.length
        }
        if (args.length < arity) {
            throw new SyntaxError(message || "Not enough arguments.")
            }
    }
    function assertType(object, type, message) {
        if (type && (typeof type == "function" ?! instanceOf(object, type): typeOf(object) != type)) {
            throw new TypeError(message || "Invalid type.")
            }
    }
    function copy(object) {
        var copy = {};
        for (var i in object) {
            copy[i] = object[i]
            }
        return copy
    }
    function pcopy(object) {
        _dummy.prototype = object;
        return new _dummy
    }
    function _dummy() {}
    function base(object, args) {
        return object.base.apply(object, args)
        }
    function extend(object, source) {
        if (object && source) {
            if (arguments.length > 2) {
                var key = source;
                source = {};
                source[key] = arguments[2]
                }
            var proto = global[(typeof source == "function" ? "Function": "Object")].prototype;
            if (base2.__prototyping) {
                var i = _HIDDEN.length,
                key;
                while ((key = _HIDDEN[ -- i])) {
                    var value = source[key];
                    if (value != proto[key]) {
                        if (_BASE.test(value)) {
                            _override(object, key, value)
                            } else {
                            object[key] = value
                        }
                    }
                }
            }
            for (key in source) {
                if (proto[key] === undefined) {
                    var value = source[key];
                    if (key.charAt(0) == "@") {
                        if (detect(key.slice(1))) {
                            extend(object, value)
                            }
                    } else {
                        var ancestor = object[key];
                        if (ancestor && typeof value == "function") {
                            if (value != ancestor) {
                                if (_BASE.test(value)) {
                                    _override(object, key, value)
                                    } else {
                                    value.ancestor = ancestor;
                                    object[key] = value
                                }
                            }
                        } else {
                            object[key] = value
                        }
                    }
                }
            }
        }
        return object
    }
    function _ancestorOf(ancestor, fn) {
        while (fn) {
            if ( ! fn.ancestor) {
                return false
            }
            fn = fn.ancestor;
            if (fn == ancestor) {
                return true
            }
        }
        return false
    }
    function _override(object, name, method) {
        var ancestor = object[name];
        var superObject = base2.__prototyping;
        if (superObject && ancestor != superObject[name]) {
            superObject = null
        }
        function _base() {
            var previous = this.base;
            this.base = superObject ? superObject[name]: ancestor;
            var returnValue = method.apply(this, arguments);
            this.base = previous;
            return returnValue
        }
        _base.method = method;
        _base.ancestor = ancestor;
        object[name] = _base;
        _base.toString = K(method + "")
        }
    if (typeof StopIteration == "undefined") {
        StopIteration = new Error("StopIteration")
        }
    function forEach(object, block, context, fn) {
        if (object == null) {
            return
        }
        if ( ! fn) {
            if (typeof object == "function" && object.call) {
                fn = Function
            } else {
                if (typeof object.forEach == "function" && object.forEach != arguments.callee) {
                    object.forEach(block, context);
                    return
                } else {
                    if (typeof object.length == "number") {
                        _Array_forEach(object, block, context);
                        return
                    }
                }
            }
        }
        _Function_forEach(fn || Object, object, block, context)
        }
    forEach.csv = function(string, block, context) {
        forEach(csv(string), block, context)
        };
    forEach.detect = function(object, block, context) {
        forEach(object, function(value, key) {
            if (key.charAt(0) == "@") {
                if (detect(key.slice(1))) {
                    forEach(value, arguments.callee)
                    }
            } else {
                block.call(context, value, key, object)
                }
        })
        };
    function _Array_forEach(array, block, context) {
        if (array == null) {
            array = global
        }
        var length = array.length || 0,
        i;
        if (typeof array == "string") {
            for (i = 0; i < length; i ++ ) {
                block.call(context, array.charAt(i), i, array)
                }
        } else {
            for (i = 0; i < length; i ++ ) {
/*@cc_on @*/
                
/*@if (@_jscript_version < 5.2)
      if ($Legacy.has(array, i))
    @else @*/
                if (i in array) {
/*@end @*/
                    block.call(context, array[i], i, array)
                    }
            }
        }
    }
    function _Function_forEach(fn, object, block, context) {
        var Temp = function() {
            this.i = 1
        };
        Temp.prototype = {
            i: 1
        };
        var count = 0;
        for (var i in new Temp) {
            count ++ 
        }
        _Function_forEach = (count > 1) ? function(fn, object, block, context) {
            var processed = {};
            for (var key in object) {
                if ( ! processed[key] && fn.prototype[key] === undefined) {
                    processed[key] = true;
                    block.call(context, object[key], key, object)
                    }
            }
        }: function(fn, object, block, context) {
            for (var key in object) {
                if (fn.prototype[key] === undefined) {
                    block.call(context, object[key], key, object)
                    }
            }
        };
        _Function_forEach(fn, object, block, context)
        }
    function instanceOf(object, klass) {
        if (typeof klass != "function") {
            throw new TypeError("Invalid 'instanceOf' operand.")
            }
        if (object == null) {
            return false;
/*@cc_on  
  // COM objects don't have a constructor
  if (typeof object.constructor != "function") {
    return typeOf(object) == typeof klass.prototype.valueOf();
  }
  @*/
            
        }
        if (object.constructor == klass) {
            return true
        }
        if (klass.ancestorOf) {
            return klass.ancestorOf(object.constructor);
/*@if (@_jscript_version < 5.1)
    // do nothing
  @else @*/
            
        }
        if (object instanceof klass) {
            return true;
/*@end @*/
            
        }
        if (Base.ancestorOf == klass.ancestorOf) {
            return false
        }
        if (Base.ancestorOf == object.constructor.ancestorOf) {
            return klass == Object
        }
        switch(klass) {
            case Array: return !! (typeof object == "object" && object.join && object.splice);
            case Function: return typeOf(object) == "function";
            case RegExp: return typeof object.constructor.$1 == "string";
            case Date: return !! object.getTimezoneOffset;
            case String: case Number: case Boolean: return typeOf(object) == typeof klass.prototype.valueOf();
            case Object: return true
        }
        return false
    }
    function typeOf(object) {
        var type = typeof object;
        switch(type) {
            case "object": return object == null ? "null": typeof object.constructor == "undefined" ? _MSIE_NATIVE_FUNCTION.test(object) ? "function": type: typeof object.constructor.prototype.valueOf();
            case "function": return typeof object.call == "function" ? type: "object";
            default: return type
        }
    }
    var JavaScript = {
        name: "JavaScript",
        version: base2.version,
        exports: "Array2,Date2,Function2,String2",
        namespace: "",
        bind: function(host) {
            var top = global;
            global = host;
            forEach.csv(this.exports, function(name2) {
                var name = name2.slice(0 ,- 1);
                extend(host[name], this[name2]);
                this[name2]
                (host[name].prototype)
                }, this);
            global = top;
            return host
        }
    };
    function _createObject2(Native, constructor, generics, extensions) {
        var INative = Module.extend();
        var id = INative.toString().slice(1 ,- 1);
        forEach.csv(generics, function(name) {
            INative[name] = unbind(Native.prototype[name]);
            INative.namespace += format("var %1=%2.%1;", name, id)
            });
        forEach(_slice.call(arguments, 3), INative.implement, INative);
        var Native2 = function() {
            return INative(this.constructor == INative ? constructor.apply(null, arguments): arguments[0])
            };
        Native2.prototype = INative.prototype;
        for (var name in INative) {
            if (name != "prototype" && Native[name]) {
                INative[name] = Native[name];
                delete INative.prototype[name]
                }
            Native2[name] = INative[name]
            }
        Native2.ancestor = Object;
        delete Native2.extend;
        Native2.namespace = Native2.namespace.replace(/(var (\w+)=)[^,;]+,([^\)]+)\)/g, "$1$3.$2");
        return Native2
    }
    if ((new Date).getYear() > 1900) {
        Date.prototype.getYear = function() {
            return this.getFullYear() - 1900
        };
        Date.prototype.setYear = function(year) {
            return this.setFullYear(year + 1900)
            }
    }
    var _testDate = new Date(Date.UTC(2006, 1, 20));
    _testDate.setUTCDate(15);
    if (_testDate.getUTCHours() != 0) {
        forEach.csv("FullYear,Month,Date,Hours,Minutes,Seconds,Milliseconds", function(type) {
            extend(Date.prototype, "setUTC" + type, function() {
                var value = base(this, arguments);
                if (value >= 57722401000) {
                    value -= 3600000;
                    this.setTime(value)
                    }
                return value
            })
            })
        }
    Function.prototype.prototype = {};
    if ("".replace(/^/, K("$$")) == "$") {
        extend(String.prototype, "replace", function(expression, replacement) {
            if (typeof replacement == "function") {
                var fn = replacement;
                replacement = function() {
                    return String(fn.apply(null, arguments)).split("$").join("$$")
                    }
            }
            return this.base(expression, replacement)
            })
        }
    var Array2 = _createObject2(Array, Array, "concat,join,pop,push,reverse,shift,slice,sort,splice,unshift", Enumerable, {
        combine: function(keys, values) {
            if ( ! values) {
                values = keys
            }
            return Array2.reduce(keys, function(hash, key, index) {
                hash[key] = values[index];
                return hash
            }, {})
            },
        contains: function(array, item) {
            return Array2.indexOf(array, item) !=- 1
        },
        copy: function(array) {
            var copy = _slice.call(array);
            if ( ! copy.swap) {
                Array2(copy)
                }
            return copy
        },
        flatten: function(array) {
            var i = 0;
            return Array2.reduce(array, function(result, item) {
                if (Array2.like(item)) {
                    Array2.reduce(item, arguments.callee, result)
                    } else {
                    result[i ++ ] = item
                }
                return result
            }, [])
            },
        forEach: _Array_forEach,
        indexOf: function(array, item, fromIndex) {
            var length = array.length;
            if (fromIndex == null) {
                fromIndex = 0
            } else {
                if (fromIndex < 0) {
                    fromIndex = Math.max(0, length + fromIndex)
                    }
            }
            for (var i = fromIndex; i < length; i ++ ) {
                if (array[i] === item) {
                    return i
                }
            }
            return - 1
        },
        insertAt: function(array, index, item) {
            Array2.splice(array, index, 0, item);
            return item
        },
        item: function(array, index) {
            if (index < 0) {
                index += array.length
            }
            return array[index]
            },
        lastIndexOf: function(array, item, fromIndex) {
            var length = array.length;
            if (fromIndex == null) {
                fromIndex = length - 1
            } else {
                if (fromIndex < 0) {
                    fromIndex = Math.max(0, length + fromIndex)
                    }
            }
            for (var i = fromIndex; i >= 0; i -- ) {
                if (array[i] === item) {
                    return i
                }
            }
            return - 1
        },
        map: function(array, block, context) {
            var result = [];
            Array2.forEach(array, function(item, index) {
                result[index] = block.call(context, item, index, array)
                });
            return result
        },
        remove: function(array, item) {
            var index = Array2.indexOf(array, item);
            if (index !=- 1) {
                Array2.removeAt(array, index)
                }
        },
        removeAt: function(array, index) {
            Array2.splice(array, index, 1)
            },
        swap: function(array, index1, index2) {
            if (index1 < 0) {
                index1 += array.length
            }
            if (index2 < 0) {
                index2 += array.length
            }
            var temp = array[index1];
            array[index1] = array[index2];
            array[index2] = temp;
            return array
        }
    });
    Array2.reduce = Enumerable.reduce;
    Array2.like = function(object) {
        return typeOf(object) == "object" && typeof object.length == "number"
    };
    Enumerable["#implemented_by"].pop();
    Enumerable["#implemented_by"].push(Array2);
    var _DATE_PATTERN = /^((-\d+|\d{4,})(-(\d{2})(-(\d{2}))?)?)?T((\d{2})(:(\d{2})(:(\d{2})(\.(\d{1,3})(\d)?\d*)?)?)?)?(([+-])(\d{2})(:(\d{2}))?|Z)?$/;
    var _DATE_PARTS = {
        FullYear: 2,
        Month: 4,
        Date: 6,
        Hours: 8,
        Minutes: 10,
        Seconds: 12,
        Milliseconds: 14
    };
    var _TIMEZONE_PARTS = {
        Hectomicroseconds: 15,
        UTC: 16,
        Sign: 17,
        Hours: 18,
        Minutes: 20
    };
    var _TRIM_ZEROES = /(((00)?:0+)?:0+)?\.0+$/;
    var _TRIM_TIMEZONE = /(T[0-9:.]+)$/;
    var Date2 = _createObject2(Date, function(yy, mm, dd, h, m, s, ms) {
        switch(arguments.length) {
            case 0: return new Date;
            case 1: return typeof yy == "number" ? new Date(yy): Date2.parse(yy);
            default: return new Date(yy, mm, arguments.length == 2 ? 1: dd, h || 0, m || 0, s || 0, ms || 0)
            }
    }, "", {
        toISOString: function(date) {
            var string = "####-##-##T##:##:##.###";
            for (var part in _DATE_PARTS) {
                string = string.replace(/#+/, function(digits) {
                    var value = date["getUTC" + part]
                    ();
                    if (part == "Month") {
                        value ++ 
                    }
                    return("000" + value).slice( - digits.length)
                    })
                }
            return string.replace(_TRIM_ZEROES, "").replace(_TRIM_TIMEZONE, "$1Z")
            }
    });
    delete Date2.forEach;
    Date2.now = function() {
        return(new Date).valueOf()
        };
    Date2.parse = function(string, defaultDate) {
        if (arguments.length > 1) {
            assertType(defaultDate, "number", "default date should be of type 'number'.")
            }
        var parts = match(string, _DATE_PATTERN);
        if (parts.length) {
            if (parts[_DATE_PARTS.Month]) {
                parts[_DATE_PARTS.Month] -- 
            }
            if (parts[_TIMEZONE_PARTS.Hectomicroseconds] >= 5) {
                parts[_DATE_PARTS.Milliseconds] ++ 
            }
            var date = new Date(defaultDate || 0);
            var prefix = parts[_TIMEZONE_PARTS.UTC] || parts[_TIMEZONE_PARTS.Hours] ? "UTC": "";
            for (var part in _DATE_PARTS) {
                var value = parts[_DATE_PARTS[part]];
                if ( ! value) {
                    continue
                }
                date["set" + prefix + part]
                (value);
                if (date["get" + prefix + part]
                () != parts[_DATE_PARTS[part]]) {
                    return NaN
                }
            }
            if (parts[_TIMEZONE_PARTS.Hours]) {
                var hours = Number(parts[_TIMEZONE_PARTS.Sign] + parts[_TIMEZONE_PARTS.Hours]);
                var minutes = Number(parts[_TIMEZONE_PARTS.Sign] + (parts[_TIMEZONE_PARTS.Minutes] || 0));
                date.setUTCMinutes(date.getUTCMinutes() + (hours * 60) + minutes)
                }
            return date.valueOf()
            } else {
            return Date.parse(string)
            }
    };
    var String2 = _createObject2(String, function(string) {
        return new String(arguments.length == 0 ? "": string)
        }, "charAt,charCodeAt,concat,indexOf,lastIndexOf,match,replace,search,slice,split,substr,substring,toLowerCase,toUpperCase", {
        csv: csv,
        format: format,
        rescape: rescape,
        trim: trim
    });
    delete String2.forEach;
    function trim(string) {
        return String(string).replace(_LTRIM, "").replace(_RTRIM, "")
        }
    function csv(string) {
        return string ? (string + "").split(/\s*,\s*/): []
        }
    function format(string) {
        var args = arguments;
        var pattern = new RegExp("%([1-" + (arguments.length - 1) + "])", "g");
        return(string + "").replace(pattern, function(match, index) {
            return args[index]
            })
        }
    function match(string, expression) {
        return(string + "").match(expression) || []
        }
    function rescape(string) {
        return(string + "").replace(_RESCAPE, "\\$1")
        }
    var Function2 = _createObject2(Function, Function, "", {
        I: I,
        II: II,
        K: K,
        bind: bind,
        compose: compose,
        delegate: delegate,
        flip: flip,
        not: not,
        partial: partial,
        unbind: unbind
    });
    function I(i) {
        return i
    }
    function II(i, ii) {
        return ii
    }
    function K(k) {
        return function() {
            return k
        }
    }
    function bind(fn, context) {
        var lateBound = typeof fn != "function";
        if (arguments.length > 2) {
            var args = _slice.call(arguments, 2);
            return function() {
                return(lateBound ? context[fn]: fn).apply(context, args.concat.apply(args, arguments))
                }
        } else {
            return function() {
                return(lateBound ? context[fn]: fn).apply(context, arguments)
                }
        }
    }
    function compose() {
        var fns = _slice.call(arguments);
        return function() {
            var i = fns.length,
            result = fns[ -- i].apply(this, arguments);
            while (i -- ) {
                result = fns[i].call(this, result)
                }
            return result
        }
    }
    function delegate(fn, context) {
        return function() {
            var args = _slice.call(arguments);
            args.unshift(this);
            return fn.apply(context, args)
            }
    }
    function flip(fn) {
        return function() {
            return fn.apply(this, Array2.swap(arguments, 0, 1))
            }
    }
    function not(fn) {
        return function() {
            return ! fn.apply(this, arguments)
            }
    }
    function partial(fn) {
        var args = _slice.call(arguments, 1);
        return function() {
            var specialised = args.concat(),
            i = 0,
            j = 0;
            while (i < args.length && j < arguments.length) {
                if (specialised[i] === undefined) {
                    specialised[i] = arguments[j ++ ]
                    }
                i ++ 
            }
            while (j < arguments.length) {
                specialised[i ++ ] = arguments[j ++ ]
                }
            if (Array2.contains(specialised, undefined)) {
                specialised.unshift(fn);
                return partial.apply(null, specialised)
                }
            return fn.apply(this, specialised)
            }
    }
    function unbind(fn) {
        return function(context) {
            return fn.apply(context, _slice.call(arguments, 1))
            }
    }
    function detect() {
        var jscript = NaN
/*@cc_on||@_jscript_version@*/
        ;
        var javaEnabled = global.java ? true: false;
        if (global.navigator) {
            var MSIE = /MSIE[\d.]+/g;
            var element = document.createElement("span");
            var userAgent = navigator.userAgent.replace(/([a-z])[\s\/](\d)/gi, "$1$2");
            if ( ! jscript) {
                userAgent = userAgent.replace(MSIE, "")
                }
            if (MSIE.test(userAgent)) {
                userAgent = userAgent.match(MSIE)[0] + " " + userAgent.replace(MSIE, "")
                }
            base2.userAgent = navigator.platform + " " + userAgent.replace(/like \w+/gi, "");
            javaEnabled &= navigator.javaEnabled()
            }
        var _cache = {};
        detect = function(expression) {
            if (_cache[expression] == null) {
                var returnValue = false,
                test = expression;
                var not = test.charAt(0) == "!";
                if (not) {
                    test = test.slice(1)
                    }
                if (test.charAt(0) == "(") {
                    try {
                        returnValue = new Function("element,jscript,java,global", "return !!" + test)
                        (element, jscript, javaEnabled, global)
                        }
                    catch(ex) {}
                } else {
                    returnValue = new RegExp("(" + test + ")", "i").test(base2.userAgent)
                    }
                _cache[expression] =!! (not ^ returnValue)
                }
            return _cache[expression]
            };
        return detect(arguments[0])
        }
    base2 = global.base2 = new Package(this, base2);
    var exports = this.exports;
    lang = new Package(this, lang);
    exports += this.exports;
    JavaScript = new Package(this, JavaScript);
    eval(exports + this.exports);
    lang.base = base;
    lang.extend = extend
};
new function(_no_shrink_) {
    var DOM = new base2.Package(this, {
        name: "DOM",
        version: "1.0.1",
        imports: "Function2",
        exports: "Interface,Binding,Node,Document,Element,AbstractView,HTMLDocument,HTMLElement,Selector,Traversal,CSSParser,XPathParser,NodeSelector,DocumentSelector,ElementSelector,StaticNodeList,Event,EventTarget,DocumentEvent,ViewCSS,CSSStyleDeclaration,ClassList",
        bind: function(node) {
            if (node && node.nodeType) {
                var base2ID = assignID(node);
                if ( ! DOM.bind[base2ID]) {
                    switch(node.nodeType) {
                        case 1: if (typeof node.className == "string") { (HTMLElement.bindings[node.tagName] || HTMLElement).bind(node)
                            } else {
                            Element.bind(node)
                            }
                        break;
                        case 9: if (node.writeln) {
                            HTMLDocument.bind(node)
                            } else {
                            Document.bind(node)
                            }
                        break;
                        default: Node.bind(node)
                        }
                    DOM.bind[base2ID] = true
                }
            }
            return node
        },
        "@MSIE5.+win": {
            bind: function(node) {
                if (node && node.writeln) {
                    node.nodeType = 9
                }
                return this.base(node)
                }
        }
    });
    eval(this.imports);
    var _MSIE = detect("MSIE");
    var _MSIE5 = detect("MSIE5");
    var Interface = Module.extend(null, {
        forEach: function(block, context) {
            forEach(this, function(method, name) {
                if (typeOf(method) == "function" && (this.prototype[name] || method._delegate)) {
                    block.call(context, method, name, this)
                    }
            }, this, Module)
            },
        implement: function(_interface) {
            if (typeof _interface == "object") {
                _createDelegates(this, _interface)
                } else {
                if (Interface.ancestorOf(_interface)) {
                    for (var name in _interface) {
                        if (_interface[name] && _interface[name]._delegate) {
                            this[name] = bind(name, _interface);
                            this[name]._delegate = name
                        }
                    }
                }
            }
            return this.base(_interface)
            }
    });
    function _createDelegates(module, _interface) {
        var id = module.toString().slice(1 ,- 1);
        for (var name in _interface) {
            var property = _interface[name];
            if (name.charAt(0) == "@") {
                _createDelegates(module, property)
                } else {
                if ( ! module[name] && typeof property == "function" && property.call) {
                    var args = "abcdefghij".slice(0, property.length).split("");
                    var fn = new Function(args.join(","), format("%2.base=%2.%1.ancestor;var m=%2.base?'base':'%1';return %2[m](%3)", name, args[0], args.slice(1)));
                    fn._delegate = name;
                    module[name] = fn;
                    module.namespace += "var " + name + "=base2.lang.bind('" + name + "'," + id + ");"
                }
            }
        }
    }
    var Binding = Interface.extend(null, {
        extend: function(_interface, _static) {
            if (_static && _static.bind != Function.bind) {
                var bind = _static.bind;
                delete _static.bind
            }
            var binding = this.base(_interface, _static);
            binding.bind = this.bind;
            if (bind) {
                extend(binding, "bind", bind)
                }
            return binding
        },
        bind: function(object) {
            return extend(object, this.prototype)
            }
    });
    var Node = Binding.extend( {
        "@!(element.compareDocumentPosition)": {
            compareDocumentPosition: function(node, other) {
                if (Traversal.contains(node, other)) {
                    return 4 | 16
                } else {
                    if (Traversal.contains(other, node)) {
                        return 2 | 8
                    }
                }
                var nodeIndex = _getSourceIndex(node);
                var otherIndex = _getSourceIndex(other);
                if (nodeIndex < otherIndex) {
                    return 4
                } else {
                    if (nodeIndex > otherIndex) {
                        return 2
                    }
                }
                return 0
            }
        }
    }, {
        "@Gecko": {
            bind: function(node) {
                return extend(this.base(node), "removeEventListener", function() {
                    var args = Array2.slice(arguments);
                    args.unshift(this);
                    EventTarget.removeEventListener.apply(EventTarget, args)
                    })
                }
        }
    });
    var _getSourceIndex = document.documentElement.sourceIndex ? function(node) {
        return node.sourceIndex
    }: function(node) {
        var key = 0;
        while (node) {
            key = Traversal.getNodeIndex(node) + "." + key;
            node = node.parentNode
        }
        return key
    };
    var Document = Node.extend(null, {
        bind: function(document) {
            extend(document, "createElement", function(tagName) {
                return DOM.bind(this.base(tagName))
                });
            AbstractView.bind(document.defaultView);
            if (document != window.document) {
                new DOMContentLoadedEvent(document)
                }
            return this.base(document)
            },
        "@!(document.defaultView)": {
            bind: function(document) {
                document.defaultView = Traversal.getDefaultView(document);
                return this.base(document)
                }
        }
    });
    var _ATTRIBUTES = {
        "class": "className",
        "for": "htmlFor"
    };
    var Element = Node.extend( {
        "@MSIE.+win": {
            getAttribute: function(element, name) {
                if (element.className === undefined) {
                    return this.base(element, name)
                    }
                var attribute = _getAttributeNode(element, name);
                if (attribute && (attribute.specified || name == "value")) {
                    if (name == "href" || name == "src") {
                        element.base = element.getAttribute.ancestor;
                        return element[element.base ? "base": "getAttribute"]
                        (name, 2)
                        } else {
                        if (name == "style") {
                            return element.style.cssText.toLowerCase()
                            } else {
                            return attribute.nodeValue
                        }
                    }
                } else {
                    if (name == "type" && element.nodeName == "INPUT") {
                        var outerHTML = element.outerHTML;
                        with(outerHTML) {
                            outerHTML = slice(0, indexOf(">") + 1)
                            }
                        return match(outerHTML, /type="?([^\s">]*)"?/i)[1] || null
                    }
                }
                return null
            },
            removeAttribute: function(element, name) {
                if (element.className !== undefined) {
                    name = _ATTRIBUTES[name.toLowerCase()] || name
                }
                this.base(element, name)
                },
            setAttribute: function(element, name, value) {
                if (element.className === undefined) {
                    this.base(element, name, value)
                    } else {
                    if (name == "style") {
                        element.style.cssText = value
                    } else {
                        value = String(value);
                        var attribute = _getAttributeNode(element, name);
                        if (attribute) {
                            attribute.nodeValue = value
                        } else {
                            this.base(element, _ATTRIBUTES[name.toLowerCase()] || name, value)
                            }
                    }
                }
            }
        },
        "@!(element.hasAttribute)": {
            hasAttribute: function(element, name) {
                if (element.className === undefined) {
                    return this.base(element, name)
                    }
                return this.getAttribute(element, name) != null
            }
        }
    });
    if (detect("MSIE.+win")) {
        extend(Element.prototype, "cloneNode", function(deep) {
            var clone = this.base(deep || false);
            clone.base2ID = undefined;
            return clone
        })
        }
    var _HTML_ATTRIBUTES = "colSpan,rowSpan,vAlign,dateTime,accessKey,tabIndex,encType,maxLength,readOnly,longDesc";
    extend(_ATTRIBUTES, Array2.combine(_HTML_ATTRIBUTES.toLowerCase().split(","), _HTML_ATTRIBUTES.split(",")));
    var _getAttributeNode = document.documentElement.getAttributeNode ? function(element, name) {
        return element.getAttributeNode(name)
        }: function(element, name) {
        return element.attributes[name] || element.attributes[_ATTRIBUTES[name.toLowerCase()]]
        };
    var TEXT = detect("(element.textContent===undefined)") ? "innerText": "textContent";
    var Traversal = Module.extend( {
        getDefaultView: function(node) {
            return this.getDocument(node).defaultView
        },
        getNextElementSibling: function(node) {
            while (node && (node = node.nextSibling) &&! this.isElement(node)) {
                continue
            }
            return node
        },
        getNodeIndex: function(node) {
            var index = 0;
            while (node && (node = node.previousSibling)) {
                index ++ 
            }
            return index
        },
        getOwnerDocument: function(node) {
            return node.ownerDocument
        },
        getPreviousElementSibling: function(node) {
            while (node && (node = node.previousSibling) &&! this.isElement(node)) {
                continue
            }
            return node
        },
        getTextContent: function(node, isHTML) {
            return node[isHTML ? "innerHTML": TEXT]
            },
        isEmpty: function(node) {
            node = node.firstChild;
            while (node) {
                if (node.nodeType == 3 || this.isElement(node)) {
                    return false
                }
                node = node.nextSibling
            }
            return true
        },
        setTextContent: function(node, text, isHTML) {
            return node[isHTML ? "innerHTML": TEXT] = text
        },
        "@!MSIE": {
            setTextContent: function(node, text, isHTML) {
                with(node) {
                    while (lastChild) {
                        parentNode.removeChild(lastChild)
                        }
                }
                return this.base(node, text, isHTML)
                }
        },
        "@MSIE": {
            getDefaultView: function(node) {
                return(node.document || node).parentWindow
            },
            "@MSIE5": {
                getOwnerDocument: function(node) {
                    return node.ownerDocument || node.document
                }
            }
        }
    }, {
        contains: function(node, target) {
            node.nodeType;
            while (target && (target = target.parentNode) && node != target) {
                continue
            }
            return !! target
        },
        getDocument: function(node) {
            return this.isDocument(node) ? node: node.ownerDocument || node.document
        },
        isDocument: function(node) {
            return !! (node && node.documentElement)
            },
        isElement: function(node) {
            return !! (node && node.nodeType == 1)
            },
        "@(element.contains)": {
            contains: function(node, target) {
                return node != target && (this.isDocument(node) ? node == this.getOwnerDocument(target): node.contains(target))
                }
        },
        "@MSIE5": {
            isElement: function(node) {
                return !! (node && node.nodeType == 1 && node.nodeName != "!")
                }
        }
    });
    var AbstractView = Binding.extend();
    var _CAPTURE_TYPE = {},
    _TYPE_MAP = {
        "2": 2,
        "4": 1
    };
    var _CAPTURING_PHASE = 1,
    _AT_TARGET = 2,
    _BUBBLING_PHASE = 3;
    var _MOUSE_BUTTON = /^mouse(up|down)|click$/,
    _MOUSE_CLICK = /click$/,
    _BUBBLES = "abort|error|select|change|resize|scroll|",
    _CANCELABLE = "(dbl)?click|mouse(down|up|over|move|out|wheel)|key(down|up)|submit|reset";
    _BUBBLES = new RegExp("^(" + _BUBBLES + _CANCELABLE + ")$");
    _CANCELABLE = new RegExp("^(" + _CANCELABLE + ")$");
    if (_MSIE) {
        var _W3C_EVENT_TYPE = {
            focusin: "focus",
            focusout: "blur"
        };
        _CAPTURE_TYPE = {
            focus: "focusin",
            blur: "focusout"
        }
    }
    var _CAN_DELEGATE = /^(blur|submit|reset|change|select)$|^(mouse|key|focus)|click$/;
    var Event = Binding.extend( {
        "@!(document.createEvent)": {
            initEvent: function(event, type, bubbles, cancelable) {
                event.type = String(type);
                event.bubbles =!! bubbles;
                event.cancelable =!! cancelable
            },
            preventDefault: function(event) {
                if (event.cancelable !== false) {
                    event.returnValue = false
                }
            },
            stopPropagation: function(event) {
                event.cancelBubble = true
            },
            "@MSIE": {
                preventDefault: function(event) {
                    this.base(event);
                    if (event.type == "mousedown") {
                        var type = "onbeforedeactivate";
                        var document = Traversal.getDocument(event.target);
                        document.attachEvent(type, function(event) {
                            event.returnValue = false;
                            document.detachEvent(type, arguments.callee)
                            })
                        }
                }
            }
        }
    }, {
        CAPTURING_PHASE: _CAPTURING_PHASE,
        AT_TARGET: _AT_TARGET,
        BUBBLING_PHASE: _BUBBLING_PHASE,
        "@!(document.createEvent)": {
            "@MSIE": {
                bind: function(event) {
                    var type = event.type;
                    if ( ! event.timeStamp) {
                        event.bubbles = _BUBBLES.test(type);
                        event.cancelable = _CANCELABLE.test(type);
                        event.timeStamp = new Date().valueOf()
                        }
                    event.relatedTarget = event[(event.target == event.fromElement ? "to": "from") + "Element"];
                    return this.base(event)
                    }
            }
        },
        cloneEvent: function(event) {
            var clone = copy(event);
            clone.stopPropagation = function() {
                event.stopPropagation()
                };
            clone.preventDefault = function() {
                event.preventDefault()
                };
            return clone
        },
        "@MSIE": {
            cloneEvent: copy
        }
    });
    var EventDispatcher = Base.extend( {
        constructor: function(state) {
            this.state = state;
            this.events = state.events
        },
        dispatch: function(nodes, event, phase) {
            event.eventPhase = phase;
            var map = this.events[event.type][phase];
            if (map) {
                var i = nodes.length;
                while (i --&&! event.cancelBubble) {
                    var currentTarget = nodes[i];
                    var listeners = map[currentTarget.base2ID];
                    if (listeners) {
                        listeners = copy(listeners);
                        event.currentTarget = currentTarget;
                        event.eventPhase = currentTarget == event.target ? _AT_TARGET: phase;
                        for (var listenerID in listeners) {
                            var listener = listeners[listenerID];
                            if (typeof listener == "function") {
                                listener.call(currentTarget, event)
                                } else {
                                listener.handleEvent(event)
                                }
                        }
                    }
                }
            }
        },
        handleEvent: function(event, fixed) {
            Event.bind(event);
            var type = event.type;
            var w3cType = _W3C_EVENT_TYPE[type];
            if (w3cType) {
                event = copy(event);
                type = event.type = w3cType
            }
            if (this.events[type]) {
                if (_MOUSE_BUTTON.test(type)) {
                    var button = _MOUSE_CLICK.test(type) ? this.state._button: event.button;
                    button = _TYPE_MAP[button] || 0;
                    if (event.button != button) {
                        event = copy(event);
                        event.button = button
                    }
                }
                var currentTarget = event.target;
                var nodes = [],
                i = 0;
                while (currentTarget) {
                    nodes[i ++ ] = currentTarget;
                    currentTarget = currentTarget.parentNode
                }
                this.dispatch(nodes, event, _CAPTURING_PHASE);
                if ( ! event.cancelBubble) {
                    if ( ! event.bubbles) {
                        nodes.length = 1
                    }
                    nodes.reverse();
                    this.dispatch(nodes, event, _BUBBLING_PHASE)
                    }
            }
            return event.returnValue !== false
        },
        "@MSIE.+win": {
            handleEvent: function(event) {
                if (event.type == "scroll") {
                    setTimeout(bind(this.base, this, copy(event), true), 0);
                    return true
                } else {
                    return this.base(event)
                    }
            },
            "@MSIE5": {
                dispatch: function(nodes, event, phase) {
                    if (phase == _CAPTURING_PHASE &&! Array2.item(nodes ,- 1).documentElement) {
                        nodes.push(nodes[0].document)
                        }
                    this.base(nodes, event, phase)
                    }
            }
        }
    });
    var _wrappedListeners = {};
    var EventTarget = Interface.extend( {
        "@!(element.addEventListener)": {
            addEventListener: function(target, type, listener, useCapture) {
                var documentState = DocumentState.getInstance(target);
                var targetID = assignID(target);
                var listenerID = assignID(listener);
                var phase = useCapture ? _CAPTURING_PHASE: _BUBBLING_PHASE;
                var typeMap = documentState.registerEvent(type, target);
                var phaseMap = typeMap[phase];
                if ( ! phaseMap) {
                    phaseMap = typeMap[phase] = {}
                }
                if (useCapture) {
                    type = _CAPTURE_TYPE[type] || type
                }
                var listeners = phaseMap[targetID];
                if ( ! listeners) {
                    listeners = phaseMap[targetID] = {}
                }
                listeners[listenerID] = listener
            },
            dispatchEvent: function(target, event) {
                event.target = target;
                return DocumentState.getInstance(target).handleEvent(event)
                },
            removeEventListener: function(target, type, listener, useCapture) {
                var events = DocumentState.getInstance(target).events;
                var typeMap = events[type];
                if (typeMap) {
                    var phaseMap = typeMap[useCapture ? _CAPTURING_PHASE: _BUBBLING_PHASE];
                    if (phaseMap) {
                        var listeners = phaseMap[target.base2ID];
                        if (listeners) {
                            delete listeners[listener.base2ID]
                            }
                    }
                }
            }
        },
        "@(element.addEventListener)": {
            "@Gecko": {
                addEventListener: function(target, type, listener, useCapture) {
                    if (type == "mousewheel") {
                        type = "DOMMouseScroll";
                        var originalListener = listener;
                        listener = _wrappedListeners[assignID(listener)] = function(event) {
                            event = Event.cloneEvent(event);
                            event.type = "mousewheel";
                            event.wheelDelta = ( - event.detail * 40) || 0;
                            _handleEvent(target, originalListener, event)
                            }
                    }
                    this.base(target, type, listener, useCapture)
                    }
            },
            "@webkit[1-4]|KHTML[34]": {
                addEventListener: function(target, type, listener, useCapture) {
                    if (_MOUSE_BUTTON.test(type)) {
                        var originalListener = listener;
                        listener = _wrappedListeners[assignID(listener)] = function(event) {
                            var button = _TYPE_MAP[event.button] || 0;
                            if (event.button != button) {
                                event = Event.cloneEvent(event);
                                event.button = button
                            }
                            _handleEvent(target, originalListener, event)
                            }
                    } else {
                        if (typeof listener == "object") {
                            listener = _wrappedListeners[assignID(listener)] = bind("handleEvent", listener)
                            }
                    }
                    this.base(target, type, listener, useCapture)
                    }
            },
            "@Linux|Mac|opera": {
                addEventListener: function(target, type, listener, useCapture) {
                    if (type == "keydown") {
                        var originalListener = listener;
                        listener = _wrappedListeners[assignID(listener)] = function(keydownEvent) {
                            var firedCount = 0,
                            cancelled = false;
                            extend(keydownEvent, "preventDefault", function() {
                                this.base();
                                cancelled = true
                            });
                            function handleEvent(event) {
                                if (cancelled) {
                                    event.preventDefault()
                                    }
                                if (event == keydownEvent || firedCount > 1) {
                                    _handleEvent(target, originalListener, keydownEvent)
                                    }
                                firedCount ++ 
                            }
                            handleEvent(keydownEvent);
                            target.addEventListener("keyup", function() {
                                target.removeEventListener("keypress", handleEvent, true);
                                target.removeEventListener("keyup", arguments.callee, true)
                                }, true);
                            target.addEventListener("keypress", handleEvent, true)
                            }
                    }
                    this.base(target, type, listener, useCapture)
                    }
            },
            removeEventListener: function(target, type, listener, useCapture) {
                this.base(target, type, _wrappedListeners[listener.base2ID] || listener, useCapture)
                }
        }
    });
    if (detect("Gecko")) {
        EventTarget.removeEventListener._delegate = "removeEventListener";
        delete EventTarget.prototype.removeEventListener
    }
    function _handleEvent(target, listener, event) {
        if (typeof listener == "function") {
            listener.call(target, event)
            } else {
            listener.handleEvent(event)
            }
    }
    var DocumentEvent = Interface.extend( {
        "@!(document.createEvent)": {
            createEvent: function(document, type) {
                var event = document.createEventObject ? document.createEventObject(): {};
                event.bubbles = false;
                event.cancelable = false;
                event.eventPhase = 0;
                event.target = document;
                event.currentTarget = null;
                event.relatedTarget = null;
                event.timeStamp = new Date().valueOf();
                return Event(event)
                }
        },
        "@(document.createEvent)": {
            "@!(document.createEvent('Events'))": {
                createEvent: function(document, type) {
                    return this.base(document, type == "Events" ? "UIEvents": type)
                    }
            }
        }
    });
    var DOMContentLoadedEvent = Base.extend( {
        constructor: function(document) {
            var fired = false;
            this.fire = function() {
                if ( ! fired) {
                    fired = true;
                    setTimeout(function() {
                        var event = DocumentEvent.createEvent(document, "Events");
                        Event.initEvent(event, "DOMContentLoaded", true, false);
                        EventTarget.dispatchEvent(document, event)
                        }, 1)
                    }
            };
            EventTarget.addEventListener(document, "DOMContentLoaded", function() {
                fired = true
            }, false);
            this.listen(document)
            },
        listen: Undefined,
        "@!Gecko20([^0]|0[3-9])|Webkit[5-9]|Opera[19]|MSIE.+mac": {
            listen: function(document) {
                EventTarget.addEventListener(Traversal.getDefaultView(document), "load", this.fire, false)
                },
            "@MSIE.+win": {
                listen: function(document) {
                    try {
                        document.body.doScroll("left");
                        if ( ! this.__constructing) {
                            this.fire()
                            }
                    }
                    catch(e) {
                        setTimeout(bind(this.listen, this, document), 10)
                        }
                }
            },
            "@KHTML": {
                listen: function(document) {
                    if (/loaded|complete/.test(document.readyState)) {
                        if ( ! this.__constructing) {
                            this.fire()
                            }
                    } else {
                        setTimeout(bind(this.listen, this, document), 10)
                        }
                }
            }
        }
    });
    Document.implement(DocumentEvent);
    Document.implement(EventTarget);
    Element.implement(EventTarget);
    var _PIXEL = /^\d+(px)?$/i,
    _METRICS = /(width|height|top|bottom|left|right|fontSize)$/,
    _COLOR = /^(color|backgroundColor)$/,
    _RGB_BLACK = "rgb(0, 0, 0)",
    _BLACK = {
        black: 1,
        "#000": 1,
        "#000000": 1
    };
    var ViewCSS = Interface.extend( {
        "@!(document.defaultView.getComputedStyle)": {
            "@MSIE": {
                getComputedStyle: function(view, element, pseudoElement) {
                    var currentStyle = element.currentStyle;
                    var computedStyle = {};
                    for (var propertyName in currentStyle) {
                        if (_METRICS.test(propertyName) || _COLOR.test(propertyName)) {
                            computedStyle[propertyName] = this.getComputedPropertyValue(view, element, propertyName)
                            } else {
                            if (propertyName.indexOf("ruby") != 0) {
                                computedStyle[propertyName] = currentStyle[propertyName]
                                }
                        }
                    }
                    return computedStyle
                }
            }
        },
        getComputedStyle: function(view, element, pseudoElement) {
            return _CSSStyleDeclaration_ReadOnly.bind(this.base(view, element, pseudoElement))
            }
    }, {
        getComputedPropertyValue: function(view, element, propertyName) {
            return CSSStyleDeclaration.getPropertyValue(this.getComputedStyle(view, element, null), propertyName)
            },
        "@MSIE": {
            getComputedPropertyValue: function(view, element, propertyName) {
                propertyName = this.toCamelCase(propertyName);
                var value = element.currentStyle[propertyName];
                if (_METRICS.test(propertyName)) {
                    return _MSIE_getPixelValue(element, value) + "px"
                }
                if ( ! _MSIE5 && _COLOR.test(propertyName)) {
                    var rgb = _MSIE_getColorValue(element, propertyName == "color" ? "ForeColor": "BackColor");
                    return(rgb == _RGB_BLACK &&! _BLACK[value]) ? value: rgb
                }
                return value
            }
        },
        toCamelCase: function(string) {
            return string.replace(/\-([a-z])/g, flip(String2.toUpperCase))
            }
    });
    function _MSIE_getPixelValue(element, value) {
        if (_PIXEL.test(value)) {
            return parseInt(value)
            }
        var styleLeft = element.style.left;
        var runtimeStyleLeft = element.runtimeStyle.left;
        element.runtimeStyle.left = element.currentStyle.left;
        element.style.left = value || 0;
        value = element.style.pixelLeft;
        element.style.left = styleLeft;
        element.runtimeStyle.left = runtimeStyleLeft;
        return value
    }
    function _MSIE_getColorValue(element, type) {
        if (element.createTextRange) {
            var range = element.createTextRange()
            } else {
            range = element.document.body.createTextRange();
            range.moveToElementText(element)
            }
        var color = range.queryCommandValue(type);
        return format("rgb(%1, %2, %3)", color & 255, (color & 65280) >> 8, (color & 16711680) >> 16)
        }
    var _CSSStyleDeclaration_ReadOnly = Binding.extend( {
        getPropertyValue: function(style, propertyName) {
            return this.base(style, _CSSPropertyNameMap[propertyName] || propertyName)
            },
        "@MSIE.+win": {
            getPropertyValue: function(style, propertyName) {
                return propertyName == "float" ? style.styleFloat: style[ViewCSS.toCamelCase(propertyName)]
                }
        }
    });
    var CSSStyleDeclaration = _CSSStyleDeclaration_ReadOnly.extend( {
        setProperty: function(style, propertyName, value, priority) {
            return this.base(style, _CSSPropertyNameMap[propertyName] || propertyName, value, priority)
            },
        "@MSIE.+win": {
            setProperty: function(style, propertyName, value, priority) {
                if (propertyName == "opacity") {
                    value *= 100;
                    style.opacity = value;
                    style.zoom = 1;
                    style.filter = "Alpha(opacity=" + value + ")"
                } else {
                    if (priority == "important") {
                        style.cssText += format(";%1:%2!important;", propertyName, value)
                        } else {
                        style.setAttribute(ViewCSS.toCamelCase(propertyName), value)
                        }
                }
            }
        }
    }, {
        "@MSIE": {
            bind: function(style) {
                style.getPropertyValue = this.prototype.getPropertyValue;
                style.setProperty = this.prototype.setProperty;
                return style
            }
        }
    });
    var _CSSPropertyNameMap = new Base( {
        "@Gecko": {
            opacity: "-moz-opacity"
        },
        "@KHTML": {
            opacity: "-khtml-opacity"
        }
    });
    with(CSSStyleDeclaration.prototype) {
        getPropertyValue.toString = setProperty.toString = K("[base2]")
        }
    AbstractView.implement(ViewCSS);
    var NodeSelector = Interface.extend( {
        "@(element.querySelector)": {
            querySelector: function(node, selector) {
                try {
                    var element = this.base(node, trim(selector));
                    if (element) {
                        return element
                    }
                }
                catch(x) {}
                return new Selector(selector).exec(node, 1)
                },
            querySelectorAll: function(node, selector) {
                try {
                    var nodeList = this.base(node, trim(selector));
                    if (nodeList) {
                        return new StaticNodeList(nodeList)
                        }
                }
                catch(x) {}
                return new Selector(selector).exec(node)
                }
        },
        "@!(element.querySelector)": {
            querySelector: function(node, selector) {
                return new Selector(selector).exec(node, 1)
                },
            querySelectorAll: function(node, selector) {
                return new Selector(selector).exec(node)
                }
        }
    });
    extend(NodeSelector.prototype, {
        querySelector: function(selector) {
            return DOM.bind(this.base(selector))
            },
        querySelectorAll: function(selector) {
            return extend(this.base(selector), "item", function(index) {
                return DOM.bind(this.base(index))
                })
            }
    });
    var DocumentSelector = NodeSelector.extend();
    var ElementSelector = NodeSelector.extend( {
        "@!(element.matchesSelector)": {
            matchesSelector: function(element, selector) {
                return new Selector(selector).test(element)
                }
        }
    });
    var _CSS_ESCAPE = /'(\\.|[^'\\])*'|"(\\.|[^"\\])*"/g,
    _CSS_IMPLIED_ASTERISK = /([\s>+~,]|[^(]\+|^)([#.:\[])/g,
    _CSS_IMPLIED_SPACE = /(^|,)([^\s>+~])/g,
    _CSS_WHITESPACE = /\s*([\s>+~,]|^|$)\s*/g,
    _CSS_WILD_CARD = /\s\*\s/g,
    _CSS_UNESCAPE = /\x01(\d+)/g,
    _QUOTE = /'/g;
    var CSSParser = RegGrp.extend( {
        constructor: function(items) {
            this.base(items);
            this.cache = {};
            this.sorter = new RegGrp;
            this.sorter.add(/:not\([^)]*\)/, RegGrp.IGNORE);
            this.sorter.add(/([ >](\*|[\w-]+))([^: >+~]*)(:\w+-child(\([^)]+\))?)([^: >+~]*)/, "$1$3$6$4")
            },
        cache: null,
        ignoreCase: true,
        escape: function(selector, simple) {
            var strings = this._strings = [];
            selector = this.optimise(this.format(String(selector).replace(_CSS_ESCAPE, function(string) {
                return "\x01" + strings.push(string.slice(1 ,- 1).replace(_QUOTE, "\\'"))
                })));
            if (simple) {
                selector = selector.replace(/^ \*?/, "")
                }
            return selector
        },
        format: function(selector) {
            return selector.replace(_CSS_WHITESPACE, "$1").replace(_CSS_IMPLIED_SPACE, "$1 $2").replace(_CSS_IMPLIED_ASTERISK, "$1*$2")
            },
        optimise: function(selector) {
            return this.sorter.exec(selector.replace(_CSS_WILD_CARD, ">* "))
            },
        parse: function(selector, simple) {
            return this.cache[selector] || (this.cache[selector] = this.unescape(this.exec(this.escape(selector, simple))))
            },
        unescape: function(selector) {
            var strings = this._strings;
            return selector.replace(_CSS_UNESCAPE, function(match, index) {
                return strings[index - 1]
                })
            }
    });
    function _nthChild(match, args, position, last, not, and, mod, equals) {
        last = /last/i.test(match) ? last + "+1-": "";
        if ( ! isNaN(args)) {
            args = "0n+" + args
        } else {
            if (args == "even") {
                args = "2n"
            } else {
                if (args == "odd") {
                    args = "2n+1"
                }
            }
        }
        args = args.split("n");
        var a = args[0] ? (args[0] == "-") ?- 1: parseInt(args[0]): 1;
        var b = parseInt(args[1]) || 0;
        var negate = a < 0;
        if (negate) {
            a =- a;
            if (a == 1) {
                b ++ 
            }
        }
        var query = format(a == 0 ? "%3%7" + (last + b): "(%4%3-%2)%6%1%70%5%4%3>=%2", a, b, position, last, and, mod, equals);
        if (negate) {
            query = not + "(" + query + ")"
        }
        return query
    }
    var XPathParser = CSSParser.extend( {
        constructor: function() {
            this.base(XPathParser.build());
            this.sorter.putAt(1, "$1$4$3$6")
            },
        escape: function(selector, simple) {
            return this.base(selector, simple).replace(/,/g, "\x02")
            },
        unescape: function(selector) {
            return this.base(selector.replace(/\[self::\*\]/g, "").replace(/(^|\x02)\//g, "$1./").replace(/\x02/g, " | ")).replace(/'[^'\\]*\\'(\\.|[^'\\])*'/g, function(match) {
                return "concat(" + match.split("\\'").join("',\"'\",'") + ")"
            })
            },
        "@opera(7|8|9\\.[1-4])": {
            unescape: function(selector) {
                return this.base(selector.replace(/last\(\)/g, "count(preceding-sibling::*)+count(following-sibling::*)+1"))
                }
        }
    }, {
        build: function() {
            this.values.attributes[""] = "[@$1]";
            forEach(this.types, function(add, type) {
                forEach(this.values[type], add, this.rules)
                }, this);
            this.build = K(this.rules);
            return this.rules
        },
        optimised: {
            pseudoClasses: {
                "first-child": "[1]",
                "last-child": "[last()]",
                "only-child": "[last()=1]"
            }
        },
        rules: extend( {}, {
            "@!KHTML|opera": {
                "(^|\\x02) (\\*|[\\w-]+)#([\\w-]+)": "$1id('$3')[self::$2]"
            },
            "@!KHTML": {
                "([ >])(\\*|[\\w-]+):([\\w-]+-child(\\(([^)]+)\\))?)": function(match, token, tagName, pseudoClass, $4, args) {
                    var replacement = (token == " ") ? "//*": "/*";
                    if (/^nth/i.test(pseudoClass)) {
                        replacement += _xpath_nthChild(pseudoClass, args, "position()")
                        } else {
                        replacement += XPathParser.optimised.pseudoClasses[pseudoClass]
                        }
                    return replacement + "[self::" + tagName + "]"
                }
            }
        }),
        types: {
            identifiers: function(replacement, token) {
                this[rescape(token) + "([\\w-]+)"] = replacement
            },
            combinators: function(replacement, combinator) {
                this[rescape(combinator) + "(\\*|[\\w-]+)"] = replacement
            },
            attributes: function(replacement, operator) {
                this["\\[\\s*([\\w-]+)\\s*" + rescape(operator) + "\\s*([^\\]\\s]*)\\s*\\]"] = replacement
            },
            pseudoClasses: function(replacement, pseudoClass) {
                this[":" + pseudoClass.replace(/\(\)$/, "\\(([^)]+)\\)")] = replacement
            }
        },
        values: {
            identifiers: {
                "#": "[@id='$1'][1]",
                ".": "[contains(concat(' ',@class,' '),' $1 ')]"
            },
            combinators: {
                " ": "/descendant::$1",
                ">": "/child::$1",
                "+": "/following-sibling::*[1][self::$1]",
                "~": "/following-sibling::$1"
            },
            attributes: {
                "*=": "[contains(@$1,'$2')]",
                "^=": "[starts-with(@$1,'$2')]",
                "$=": "[substring(@$1,string-length(@$1)-string-length('$2')+1)='$2']",
                "~=": "[contains(concat(' ',@$1,' '),' $2 ')]",
                "|=": "[contains(concat('-',@$1,'-'),'-$2-')]",
                "!=": "[not(@$1='$2')]",
                "=": "[@$1='$2']"
            },
            pseudoClasses: {
                "link": "[false]",
                "visited": "[false]",
                "empty": "[not(child::*) and not(text())]",
                "first-child": "[not(preceding-sibling::*)]",
                "last-child": "[not(following-sibling::*)]",
                "not()": _xpath_not,
                "nth-child()": _xpath_nthChild,
                "nth-last-child()": _xpath_nthChild,
                "only-child": "[not(preceding-sibling::*) and not(following-sibling::*)]",
                "root": "[not(parent::*)]"
            }
        },
        "@opera(7|8|9\\.[1-4])": {
            build: function() {
                this.optimised.pseudoClasses["last-child"] = this.values.pseudoClasses["last-child"];
                this.optimised.pseudoClasses["only-child"] = this.values.pseudoClasses["only-child"];
                return this.base()
                }
        }
    });
    var _notParser;
    function _xpath_not(match, args) {
        if ( ! _notParser) {
            _notParser = new XPathParser
        }
        return "[not(" + _notParser.exec(trim(args)).replace(/\[1\]/g, "").replace(/^(\*|[\w-]+)/, "[self::$1]").replace(/\]\[/g, " and ").slice(1 ,- 1) + ")]"
    }
    function _xpath_nthChild(match, args, position) {
        return "[" + _nthChild(match, args, position || "count(preceding-sibling::*)+1", "last()", "not", " and ", " mod ", "=") + "]"
    }
    var Selector = Base.extend( {
        constructor: function(selector) {
            this.toString = K(trim(selector))
            },
        exec: function(context, count, simple) {
            return Selector.parse(this, simple)
            (context, count)
            },
        isSimple: function() {
            if ( ! _parser.exec) {
                _parser = new CSSParser(_parser)
                }
            return ! _COMBINATOR.test(trim(_parser.escape(this)))
            },
        test: function(element) {
            if (this.isSimple()) {
                return !! Selector.parse(this, true)
                (element, 1)
                } else {
                element.setAttribute("b2-test", true);
                var result = new Selector(this + "[b2-test]").exec(Traversal.getOwnerDocument(element), 1);
                element.removeAttribute("b2-test");
                return result == element
            }
        },
        toXPath: function(simple) {
            return Selector.toXPath(this, simple)
            },
        "@(XPathResult)": {
            exec: function(context, count, simple) {
                if (_NOT_XPATH.test(this)) {
                    return this.base(context, count, simple)
                    }
                var document = Traversal.getDocument(context);
                var type = count == 1 ? 9: 7;
                var result = document.evaluate(this.toXPath(simple), context, null, type, null);
                return count == 1 ? result.singleNodeValue: result
            }
        },
        "@MSIE": {
            exec: function(context, count, simple) {
                if (typeof context.selectNodes != "undefined" &&! _NOT_XPATH.test(this)) {
                    var method = single ? "selectSingleNode": "selectNodes";
                    return context[method]
                    (this.toXPath(simple))
                    }
                return this.base(context, count, simple)
                }
        },
        "@(true)": {
            exec: function(context, count, simple) {
                try {
                    var result = this.base(context || document, count, simple)
                    }
                catch(error) {
                    throw new SyntaxError(format("'%1' is not a valid CSS selector.", this))
                    }
                return count == 1 ? result: new StaticNodeList(result)
                }
        }
    }, {
        toXPath: function(selector, simple) {
            if ( ! _xpathParser) {
                _xpathParser = new XPathParser
            }
            return _xpathParser.parse(selector, simple)
            }
    });
    var _COMBINATOR = /[^,]\s|[+>~]/;
    var _NOT_XPATH = ":(checked|disabled|enabled|contains|hover|active|focus)|^(#[\\w-]+\\s*)?\\w+$";
    if (detect("KHTML")) {
        if (detect("WebKit5")) {
            _NOT_XPATH += "|nth\\-|,"
        } else {
            _NOT_XPATH = "."
        }
    }
    _NOT_XPATH = new RegExp(_NOT_XPATH);
    Selector.operators = {
        "=": "%1=='%2'",
        "~=": /(^| )%1( |$)/,
        "|=": /^%1(-|$)/,
        "^=": /^%1/,
        "$=": /%1$/,
        "*=": /%1/
    };
    Selector.operators[""] = "%1!=null";
    Selector.pseudoClasses = {
        "checked": "e%1.checked",
        "contains": "e%1[TEXT].indexOf('%2')!=-1",
        "disabled": "e%1.disabled",
        "empty": "Traversal.isEmpty(e%1)",
        "enabled": "e%1.disabled===false",
        "first-child": "!Traversal.getPreviousElementSibling(e%1)",
        "last-child": "!Traversal.getNextElementSibling(e%1)",
        "only-child": "!Traversal.getPreviousElementSibling(e%1)&&!Traversal.getNextElementSibling(e%1)",
        "root": "e%1==Traversal.getDocument(e%1).documentElement",
        "target": "e%1.id&&e%1.id==location.hash.slice(1)",
        "hover": "DocumentState.getInstance(d).isHover(e%1)",
        "active": "DocumentState.getInstance(d).isActive(e%1)",
        "focus": "DocumentState.getInstance(d).hasFocus(e%1)",
        "link": "false",
        "visited": "false"
    };
    var _INDEXED = document.documentElement.sourceIndex !== undefined,
    _VAR = "var p%2=0,i%2,e%3,n%2=e%1.",
    _ID = _INDEXED ? "e%1.sourceIndex": "assignID(e%1)",
    _TEST = "var g=" + _ID + ";if(!p[g]){p[g]=1;",
    _STORE = "r[k++]=e%1;if(s==1)return e%1;if(k===s){_query.state=[%2];_query.complete=%3;return r;",
    _FN = "var _query=function(e0,s%1){_indexed++;var r=[],p={},p0=0,reg=[%4],d=Traversal.getDocument(e0),c=d.writeln?'toUpperCase':'toString',k=0;";
    var _xpathParser;
    var _reg,
    _index,
    _wild,
    _list,
    _group,
    _listAll,
    _duplicate,
    _cache = {},
    _simple = {};
    function sum(list) {
        var total = 0;
        for (var i = 0; i < list.length; i ++ ) {
            total += list[i]
            }
        return total
    }
    var _parser = {
        "^(\\*|[\\w-]+)": function(match, tagName) {
            return tagName == "*" ? "": format("if(e0.nodeName=='%1'[c]()){", tagName)
            },
        "^ \\*:root": function(match) {
            _wild = false;
            var replacement = "e%2=d.documentElement;if(Traversal.contains(e%1,e%2)){";
            return format(replacement, _index ++, _index)
            },
        " (\\*|[\\w-]+)#([\\w-]+)": function(match, tagName, id) {
            _wild = false;
            var replacement = "var e%2=_byId(d,'%4');if(e%2&&";
            if (tagName != "*") {
                replacement += "e%2.nodeName=='%3'[c]()&&"
            }
            replacement += "Traversal.contains(e%1,e%2)){";
            if (_list[_group]) {
                replacement += format("i%1=n%1.length;", sum(_list))
                }
            return format(replacement, _index ++, _index, tagName, id)
            },
        " (\\*|[\\w-]+)": function(match, tagName) {
            _duplicate ++ ;
            _wild = tagName == "*";
            var replacement = format(_VAR, _index ++, "%2", _index);
            replacement += (_wild && _MSIE5) ? "all": "getElementsByTagName('%3')";
            replacement += ";for(i%2=a%2||0;(e%1=n%2[i%2]);i%2++){";
            _list[_group] ++ ;
            return format(replacement, _index, sum(_list), tagName)
            },
        ">(\\*|[\\w-]+)": function(match, tagName) {
            var children = _MSIE && _index;
            _wild = tagName == "*";
            var replacement = _VAR + (children ? "children": "childNodes");
            replacement = format(replacement, _index ++, "%2", _index);
            if ( ! _wild && _MSIE && children) {
                replacement += ".tags('%3')"
            }
            replacement += ";for(i%2=a%2||0;(e%1=n%2[i%2]);i%2++){";
            if (_wild) {
                replacement += "if(e%1.nodeType==1){";
                _wild = _MSIE5
            } else {
                if ( ! _MSIE ||! children) {
                    replacement += "if(e%1.nodeName=='%3'[c]()){"
                }
            }
            _list[_group] ++ ;
            return format(replacement, _index, sum(_list), tagName)
            },
        "\\+(\\*|[\\w-]+)": function(match, tagName) {
            var replacement = "";
            if (_wild && _MSIE) {
                replacement += "if(e%1.nodeName!='!'){"
            }
            _wild = false;
            replacement += "e%1=Traversal.getNextElementSibling(e%1);if(e%1";
            if (tagName != "*") {
                replacement += "&&e%1.nodeName=='%2'[c]()"
            }
            replacement += "){";
            return format(replacement, _index, tagName)
            },
        "~(\\*|[\\w-]+)": function(match, tagName) {
            var replacement = "";
            if (_wild && _MSIE) {
                replacement += "if(e%1.nodeName!='!'){"
            }
            _wild = false;
            _duplicate = 2;
            replacement += "while(e%1=e%1.nextSibling){if(e%1.b2_adjacent==_indexed)break;if(";
            if (tagName == "*") {
                replacement += "e%1.nodeType==1";
                if (_MSIE5) {
                    replacement += "&&e%1.nodeName!='!'"
                }
            } else {
                replacement += "e%1.nodeName=='%2'[c]()"
            }
            replacement += "){e%1.b2_adjacent=_indexed;";
            return format(replacement, _index, tagName)
            },
        "#([\\w-]+)": function(match, id) {
            _wild = false;
            var replacement = "if(e%1.id=='%2'){";
            if (_list[_group]) {
                replacement += format("i%1=n%1.length;", sum(_list))
                }
            return format(replacement, _index, id)
            },
        "\\.([\\w-]+)": function(match, className) {
            _wild = false;
            _reg.push(new RegExp("(^|\\s)" + rescape(className) + "(\\s|$)"));
            return format("if(e%1.className&&reg[%2].test(e%1.className)){", _index, _reg.length - 1)
            },
        ":not\\((\\*|[\\w-]+)?([^)]*)\\)": function(match, tagName, filters) {
            var replacement = (tagName && tagName != "*") ? format("if(e%1.nodeName=='%2'[c]()){", _index, tagName): "";
            replacement += _parser.exec(filters);
            return "if(!" + replacement.slice(2 ,- 1).replace(/\)\{if\(/g, "&&") + "){"
        },
        ":nth(-last)?-child\\(([^)]+)\\)": function(match, last, args) {
            _wild = false;
            last = format("e%1.parentNode.b2_length", _index);
            var replacement = "if(p%1!==e%1.parentNode)p%1=_register(e%1.parentNode);";
            replacement += "var i=e%1[p%1.b2_lookup];if(p%1.b2_lookup!='b2_index')i++;if(";
            return format(replacement, _index) + _nthChild(match, args, "i", last, "!", "&&", "% ", "==") + "){"
        },
        ":([\\w-]+)(\\(([^)]+)\\))?": function(match, pseudoClass, $2, args) {
            return "if(" + format(Selector.pseudoClasses[pseudoClass] || "throw", _index, args || "") + "){"
        },
        "\\[\\s*([\\w-]+)\\s*([^=]?=)?\\s*([^\\]\\s]*)\\s*\\]": function(match, attr, operator, value) {
            value = trim(value);
            if (_MSIE) {
                var getAttribute = "Element.getAttribute(e%1,'%2')"
            } else {
                getAttribute = "e%1.getAttribute('%2')"
            }
            getAttribute = format(getAttribute, _index, attr);
            var replacement = Selector.operators[operator || ""];
            if (instanceOf(replacement, RegExp)) {
                _reg.push(new RegExp(format(replacement.source, rescape(_parser.unescape(value)))));
                replacement = "reg[%2].test(%1)";
                value = _reg.length - 1
            }
            return "if(" + format(replacement, getAttribute, value) + "){"
        }
    }; (function(_no_shrink_) {
        var _byId = detect("MSIE[5-7]") ? function(document, id) {
            var result = document.all[id] || null;
            if ( ! result || result.id == id) {
                return result
            }
            for (var i = 0; i < result.length; i ++ ) {
                if (result[i].id == id) {
                    return result[i]
                    }
            }
            return null
        }: function(document, id) {
            return document.getElementById(id)
            };
        var _indexed = 1;
        function _register(element) {
            if (element.rows) {
                element.b2_length = element.rows.length;
                element.b2_lookup = "rowIndex"
            } else {
                if (element.cells) {
                    element.b2_length = element.cells.length;
                    element.b2_lookup = "cellIndex"
                } else {
                    if (element.b2_indexed != _indexed) {
                        var index = 0;
                        var child = element.firstChild;
                        while (child) {
                            if (child.nodeType == 1 && child.nodeName != "!") {
                                child.b2_index =++ index
                            }
                            child = child.nextSibling
                        }
                        element.b2_length = index;
                        element.b2_lookup = "b2_index"
                    }
                }
            }
            element.b2_indexed = _indexed;
            return element
        }
        Selector.parse = function(selector, simple) {
            var cache = simple ? _simple: _cache;
            if ( ! cache[selector]) {
                if ( ! _parser.exec) {
                    _parser = new CSSParser(_parser)
                    }
                _reg = [];
                _list = [];
                var fn = "";
                var selectors = _parser.escape(selector, simple).split(",");
                for (_group = 0; _group < selectors.length; _group ++ ) {
                    _wild = _index = _list[_group] = 0;
                    _duplicate = selectors.length > 1 ? 2: 0;
                    var block = _parser.exec(selectors[_group]) || "throw;";
                    if (_wild && _MSIE) {
                        block += format("if(e%1.tagName!='!'){", _index)
                        }
                    var store = (_duplicate > 1) ? _TEST: "";
                    block += format(store + _STORE, _index, "%2");
                    block += Array(match(block, /\{/g).length + 1).join("}");
                    fn += block
                }
                fn = _parser.unescape(fn);
                if (selectors.length > 1) {
                    fn += "r.unsorted=1;"
                }
                var args = "";
                var state = [];
                var total = sum(_list);
                for (var i = 1; i <= total; i ++ ) {
                    args += ",a" + i;
                    state.push("i" + i + "?(i" + i + "-1):0")
                    }
                if (total) {
                    var complete = [],
                    k = 0;
                    for (var i = 0; i < _group; i ++ ) {
                        k += _list[i];
                        if (_list[i]) {
                            complete.push(format("n%1&&i%1==n%1.length", k))
                            }
                    }
                }
                fn += "_query.state=[%2];_query.complete=%3;return s==1?null:r}";
                eval(format(_FN + fn, args, state.join(","), total ? complete.join("&&"): true, _reg));
                cache[selector] = _query
            }
            return cache[selector]
            }
    })
    ();
    var StaticNodeList = Base.extend( {
        constructor: function(nodes) {
            nodes = nodes || [];
            this.length = nodes.length;
            this.item = function(index) {
                if (index < 0) {
                    index += this.length
                }
                return nodes[index]
                };
            if (nodes.unsorted) {
                nodes.sort(_SORTER)
                }
        },
        length: 0,
        forEach: function(block, context) {
            for (var i = 0; i < this.length; i ++ ) {
                block.call(context, this.item(i), i, this)
                }
        },
        item: Undefined,
        not: function(test, context) {
            return this.filter(not(test), context)
            },
        slice: function(start, end) {
            return new StaticNodeList(this.map(I).slice(start, end))
            },
        "@(XPathResult)": {
            constructor: function(nodes) {
                if (nodes && nodes.snapshotItem) {
                    this.length = nodes.snapshotLength;
                    this.item = function(index) {
                        if (index < 0) {
                            index += this.length
                        }
                        return nodes.snapshotItem(index)
                        }
                } else {
                    this.base(nodes)
                    }
            }
        }
    });
    StaticNodeList.implement(Enumerable);
    var _matchesSelector = function(test, context) {
        if (typeof test != "function") {
            test = bind("test", new Selector(test))
            }
        return this.base(test, context)
        };
    StaticNodeList.implement( {
        every: _matchesSelector,
        filter: _matchesSelector,
        not: _matchesSelector,
        some: _matchesSelector
    });
    StaticNodeList.implement( {
        filter: function(test, context) {
            return new StaticNodeList(this.base(test, context))
            }
    });
    var _SORTER = _INDEXED ? function(node1, node2) {
        return node1.sourceIndex - node2.sourceIndex
    }: function(node1, node2) {
        return(Node.compareDocumentPosition(node1, node2) & 2) - 1
    };
    Document.implement(DocumentSelector);
    Element.implement(ElementSelector);
    var HTMLDocument = Document.extend(null, {
        bind: function(document) {
            DocumentState.createState(document);
            return this.base(document)
            }
    });
    var HTMLElement = Element.extend(null, {
        bindings: {},
        tags: "*",
        bind: function(element) {
            if ( ! element.classList) {
                element.classList = new _ElementClassList(element)
                }
            if ( ! element.ownerDocument) {
                element.ownerDocument = Traversal.getOwnerDocument(element)
                }
            return this.base(element)
            },
        extend: function() {
            var binding = base(this, arguments);
            forEach.csv(binding.tags, function(tagName) {
                HTMLElement.bindings[tagName] = binding
            });
            return binding
        }
    });
    HTMLElement.extend(null, {
        tags: "APPLET,EMBED",
        bind: I
    });
    var ClassList = Module.extend( {
        add: function(element, token) {
            if ( ! this.has(element, token)) {
                element.className += (element.className ? " ": "") + token
            }
        },
        has: function(element, token) {
            var regexp = new RegExp("(^|\\s)" + token + "(\\s|$)");
            return regexp.test(element.className)
            },
        remove: function(element, token) {
            var regexp = new RegExp("(^|\\s)" + token + "(\\s|$)", "g");
            element.className = trim(element.className.replace(regexp, "$2"))
            },
        toggle: function(element, token) {
            this[this.has(element, token) ? "remove": "add"]
            (element, token)
            }
    });
    function _ElementClassList(element) {
        this.add = function(token) {
            ClassList.add(element, token)
            };
        this.has = function(token) {
            return ClassList.has(element, token)
            };
        this.remove = function(token) {
            ClassList.remove(element, token)
            }
    }
    _ElementClassList.prototype.toggle = function(token) {
        this[this.has(token) ? "remove": "add"]
        (token)
        };
    var DocumentState = Base.extend( {
        constructor: function(document) {
            this.document = document;
            this.events = {};
            this._hoverElement = document.documentElement;
            this.isBound = function() {
                return !! DOM.bind[document.base2ID]
                };
            forEach(this, function(method, name, documentState) {
                if (/^on((DOM)?\w+|[a-z]+)$/.test(name)) {
                    documentState.registerEvent(name.slice(2))
                    }
            })
            },
        includes: function(element, target) {
            return target && (element == target || Traversal.contains(element, target))
            },
        hasFocus: function(element) {
            return element == this._focusElement
        },
        isActive: function(element) {
            return this.includes(element, this._activeElement)
            },
        isHover: function(element) {
            return this.includes(element, this._hoverElement)
            },
        handleEvent: function(event) {
            return this["on" + event.type]
            (event)
            },
        onblur: function(event) {
            delete this._focusElement
        },
        onmouseover: function(event) {
            this._hoverElement = event.target
        },
        onmouseout: function(event) {
            delete this._hoverElement
        },
        onmousedown: function(event) {
            this._activeElement = event.target
        },
        onfocus: function(event) {
            this._focusElement = event.target
        },
        onmouseup: function(event) {
            delete this._activeElement
        },
        registerEvent: function(type) {
            this.document.addEventListener(type, this, true);
            this.events[type] = true
        },
        "@(document.activeElement===undefined)": {
            constructor: function(document) {
                this.base(document);
                if (this.isBound()) {
                    document.activeElement = document.body
                }
            },
            onfocus: function(event) {
                this.base(event);
                if (this.isBound()) {
                    this.document.activeElement = this._focusElement
                }
            },
            onblur: function(event) {
                this.base(event);
                if (this.isBound()) {
                    this.document.activeElement = this.document.body
                }
            }
        },
        "@!(element.addEventListener)": {
            constructor: function(document) {
                this.base(document);
                var dispatcher = new EventDispatcher(this);
                this._dispatch = function(event) {
                    event.target = event.target || event.srcElement || document;
                    dispatcher.handleEvent(event)
                    };
                this.handleEvent = function(event) {
                    if (this["on" + event.type]) {
                        this["on" + event.type]
                        (event)
                        }
                    return dispatcher.handleEvent(event)
                    }
            },
            registerEvent: function(type, target) {
                var events = this.events[type];
                var canDelegate = _CAN_DELEGATE.test(type);
                if ( ! events ||! canDelegate) {
                    if ( ! events) {
                        events = this.events[type] = {}
                    }
                    if (canDelegate ||! target) {
                        target = this.document
                    }
                    var state = this;
                    target["on" + type] = function(event) {
                        if ( ! event) {
                            event = Traversal.getDefaultView(this).event
                        }
                        if (event) {
                            state.handleEvent(event)
                            }
                    }
                }
                return events
            },
            "@MSIE.+win": {
                constructor: function(document) {
                    this.base(document);
                    var forms = {};
                    this._registerForm = function(form) {
                        var formID = assignID(form);
                        if ( ! forms[formID]) {
                            forms[formID] = true;
                            form.attachEvent("onsubmit", this._dispatch);
                            form.attachEvent("onreset", this._dispatch)
                            }
                    }
                },
                fireEvent: function(type, event) {
                    event = copy(event);
                    event.type = type;
                    this.handleEvent(event)
                    },
                registerEvent: function(type, target) {
                    var events = this.events[type];
                    var canDelegate = _CAN_DELEGATE.test(type);
                    if ( ! events ||! canDelegate) {
                        if ( ! events) {
                            events = this.events[type] = {}
                        }
                        if (canDelegate ||! target) {
                            target = this.document
                        }
                        var state = this;
                        target.attachEvent("on" + type, function(event) {
                            event.target = event.srcElement || state.document;
                            state.handleEvent(event);
                            if (state["after" + type]) {
                                state["after" + type]
                                (event)
                                }
                        })
                        }
                    return events
                },
                onDOMContentLoaded: function(event) {
                    forEach(event.target.forms, this._registerForm, this);
                    try {
                        this.setFocus(this.document.activeElement)
                        }
                    catch(x) {}
                },
                onmousedown: function(event) {
                    this.base(event);
                    this._button = event.button
                },
                onmouseup: function(event) {
                    this.base(event);
                    if (this._button == null) {
                        this.fireEvent("mousedown", event)
                        }
                    delete this._button
                },
                aftermouseup: function() {
                    if (this._selectEvent) {
                        this._dispatch(this._selectEvent);
                        delete this._selectEvent
                    }
                },
                onfocusin: function(event) {
                    this.setFocus(event.target);
                    this.onfocus(event)
                    },
                setFocus: function(target) {
                    var change = this.events.change,
                    select = this.events.select;
                    if (change || select) {
                        var dispatch = this._dispatch;
                        if (change) {
                            target.attachEvent("onchange", dispatch)
                            }
                        if (select) {
                            var state = this;
                            var onselect = function(event) {
                                if (state._activeElement == target) {
                                    state._selectEvent = copy(event)
                                    } else {
                                    dispatch(event)
                                    }
                            };
                            target.attachEvent("onselect", onselect)
                            }
                        target.attachEvent("onblur", function() {
                            target.detachEvent("onblur", arguments.callee);
                            if (change) {
                                target.detachEvent("onchange", dispatch)
                                }
                            if (select) {
                                target.detachEvent("onselect", onselect)
                                }
                        })
                        }
                },
                onfocusout: function(event) {
                    this.onblur(event)
                    },
                onclick: function(event) {
                    var target = event.target;
                    if (target.form) {
                        this._registerForm(target.form)
                        }
                },
                ondblclick: function(event) {
                    this.fireEvent("click", event)
                    }
            }
        }
    }, {
        init: function() {
            assignID(document);
            DocumentState = this;
            this.createState(document);
            new DOMContentLoadedEvent(document)
            },
        createState: function(document) {
            var base2ID = document.base2ID;
            if ( ! this[base2ID]) {
                this[base2ID] = new this(document)
                }
            return this[base2ID]
            },
        getInstance: function(target) {
            return this[Traversal.getDocument(target).base2ID]
            }
    });
    eval(this.exports)
    };
try {
    if (NodeList &&! (NodeList.prototype.forEach)) {
        NodeList.prototype.forEach = function(B, A) {
            for (var C = 0; C < this.length; C ++ ) {
                B.call(A, this.item(C), C, this)
                }
        }
    }
}
catch(e) {}
try {
    if (typeof StaticNodeList != "undefined" &&! (StaticNodeList.prototype.forEach)) {
        StaticNodeList.prototype.forEach = function(B, A) {
            for (var C = 0; C < this.length; C ++ ) {
                B.call(A, this.item(C), C, this)
                }
        }
    }
}
catch(e) {}
if (typeof(base2) == "undefined") {
    throw new Error("Base2 not found. wForms 3 depends on the base2 library.")
    }
base2.DOM.HTMLElement.implement( {
    hasClass: function(A, B) {
        if (A.classList && A.classList.contains) {
            return A.classList.contains(B)
            } else {
            return A.className.match(new RegExp("(\\s|^)" + B + "(\\s|$)"))
            }
    },
    removeClass: function(A, B) {
        if (base2.DOM.HTMLElement.hasClass(A, B)) {
            var C = new RegExp("(\\s|^)" + B + "(\\s|$)");
            A.className = A.className.replace(C, " ").replace(/^\s+|\s+$/g, "")
            }
    },
    addClass: function(A, B) {
        if ( ! base2.DOM.HTMLElement.hasClass(A, B)) {
            A.className = (A.className + " " + B).replace(/^\s+|\s+$/g, "")
            }
    }
});
if (typeof(wFORMS) == "undefined") {
    wFORMS = {}
}
wFORMS.NAME = "wFORMS";
wFORMS.VERSION = "3.4";
wFORMS.__repr__ = function() {
    return "[" + this.NAME + " " + this.VERSION + "]"
};
wFORMS.toString = function() {
    return this.__repr__()
    };
wFORMS.behaviors = {};
wFORMS.helpers = {};
wFORMS.instances = [];
wFORMS.helpers.randomId = function() {
    var A = (new Date()).getTime();
    A = A.toString().substr(6);
    for (var B = 0; B < 6; B ++ ) {
        A += String.fromCharCode(48 + Math.floor((Math.random() * 10)))
        }
    return "id_" + A
};
wFORMS.helpers.getFieldValue = function(C) {
    switch(C.tagName) {
        case "INPUT": if (C.type == "checkbox") {
            return C.checked ? C.value: null
        }
        if (C.type == "radio") {
            return C.checked ? C.value: null
        }
        return C.value;
        break;
        case "SELECT": if (C.selectedIndex ==- 1) {
            return null
        }
        if (C.getAttribute("multiple")) {
            var A = [];
            for (var B = 0; B < C.options.length; B ++ ) {
                if (C.options[B].selected) {
                    A.push(C.options[B].value)
                    }
            }
            return A
        }
        return C.options[C.selectedIndex].value;
        break;
        case "TEXTAREA": return C.value;
        break;
        default: return null;
        break
    }
};
wFORMS.helpers.getComputedStyle = function(B, A) {
    return document.defaultView.getComputedStyle(B, "").getPropertyValue(A)
    };
wFORMS.helpers.getForm = function(A) {
    if (A.form) {
        wFORMS.standardizeElement(A.form);
        return A.form
    } else {
        if (A.parentNode) {
            if (A.parentNode.tagName.toLowerCase() == "form") {
                wFORMS.standardizeElement(A.parentNode);
                return A.parentNode
            } else {
                return this.getForm(A.parentNode)
                }
        } else {
            return null
        }
    }
};
wFORMS.helpers.getLeft = function(B) {
    var C = 0;
    while (B.offsetParent) {
        try {
            if (document.defaultView.getComputedStyle(B, "").getPropertyValue("position") == "relative") {
                return C
            }
            if (C > 0 && document.defaultView.getComputedStyle(B, "").getPropertyValue("position") == "absolute") {
                return C
            }
        }
        catch(A) {}
        C += B.offsetLeft;
        B = B.offsetParent
    }
    if ( ! window.opera && document.all && document.compatMode && document.compatMode != "BackCompat") {
        C += parseInt(document.body.currentStyle.marginTop)
        }
    return C
};
wFORMS.helpers.getTop = function(B) {
    var C = 0;
    while (B.offsetParent) {
        try {
            if (document.defaultView.getComputedStyle(B, "").getPropertyValue("position") == "relative") {
                return C
            }
            if (C > 0 && document.defaultView.getComputedStyle(B, "").getPropertyValue("position") == "absolute") {
                return C
            }
        }
        catch(A) {}
        C += B.offsetTop;
        B = B.offsetParent
    }
    if ( ! window.opera && document.all && document.compatMode && document.compatMode != "BackCompat") {
        C += parseInt(document.body.currentStyle.marginLeft) + 1
    }
    return C
};
wFORMS.helpers.position = function(B) {
    var A = B.offsetLeft;
    var D = B.offsetTop;
    if (B.offsetParent) {
        var C = this.position(B.offsetParent);
        A += C.left;
        D += C.top
    }
    return {
        left: A,
        top: D
    }
};
wFORMS.helpers.useSpotlight = false;
wFORMS.helpers.spotlight = function(A) {};
wFORMS.helpers.activateStylesheet = function(C) {
    if (document.getElementsByTagName) {
        var B = document.getElementsByTagName("link")
        } else {
        if (document.styleSheets) {
            var B = document.styleSheets
        }
    }
    for (var A = 0; B[A]; A ++ ) {
        if (B[A].href.indexOf(C) !=- 1) {
            B[A].disabled = true;
            B[A].disabled = false
        }
    }
};
wFORMS.helpers.contains = function(D, C) {
    var A = D.length;
    for (var B = 0; B < A; B ++ ) {
        if (D[B] === C) {
            return true
        }
    }
    return false
};
wFORMS.LOADER = {};
wFORMS.LOADER.enabled = false;
wFORMS.LOADER.message = "Please wait...";
wFORMS.LOADER.spinner = "";
wFORMS.LOADER.speed = 2;
wFORMS.LOADER.show = function(placeholder) {
    if (wFORMS.LOADER.enabled) {
        var p = wFORMS.LOADER.create();
        p.style.visibility = "hidden";
        p.style.overflow = "hidden";
/*@cc_on
		@if(@_jscript_version <= 5.7)
			p.style.width = "100%"; // triggers hasLayout in IE6			
		@end
		@*/
        var where = (arguments[1] == "above") ? placeholder: placeholder.nextSibling;
        p = placeholder.parentNode.insertBefore(p, where);
        p.id = "wfLoader_" + placeholder.id;
        wFORMS.LOADER._id = p.id;
        var h = p.clientHeight;
        p.style.height = h + "px";
        wFORMS.LOADER._padding = p.clientHeight - h;
        p.style.height = (h - wFORMS.LOADER._padding) + "px";
        p.style.visibility = "visible"
    }
};
wFORMS.LOADER.hide = function(B) {
    if (wFORMS.LOADER.enabled && wFORMS.LOADER._id) {
        var A = document.getElementById(wFORMS.LOADER._id);
        if (A) {
            if (arguments[1]) {
                A.parentNode.removeChild(A)
                } else {
                wFORMS.LOADER._interval = setInterval(function() {
                    var C = A.clientHeight - wFORMS.LOADER.speed - wFORMS.LOADER._padding;
                    if (C < 0) {
                        C = 0
                    }
                    A.style.height = C + "px";
                    if (A &&! (A.clientHeight - wFORMS.LOADER._padding)) {
                        A.parentNode.removeChild(A);
                        clearInterval(wFORMS.LOADER._interval)
                        }
                }, 10)
                }
        }
        wFORMS.LOADER._id = null
    }
};
wFORMS.LOADER.create = function() {
    var C = document.createElement("DIV");
    C.className = "wfLoader";
    var B = C.appendChild(document.createElement("DIV"));
    B.className = "inner";
    if (wFORMS.LOADER.spinner) {
        var A = B.appendChild(document.createElement("IMG"));
        A.src = wFORMS.LOADER.spinner
    }
    if (wFORMS.LOADER.message) {
        B.appendChild(document.createTextNode(wFORMS.LOADER.message))
        }
    return C
};
wFORMS.onLoadHandler = function() {
    var A = document.getElementsByTagName("FORM");
    for (var B = 0; B < A.length; B ++ ) {
        var C = function(D) {
            if (D.getAttribute("rel") != "no-behavior") {
                wFORMS.LOADER.show(D, "above");
                setTimeout(function() {
                    wFORMS.applyBehaviors(D);
                    wFORMS.LOADER.hide(D)
                    }, 1)
                }
        } (A[B])
        }
};
wFORMS.standardizeElement = function(A) {
    if ( ! A.addEventListener) {
        A.addEventListener = function(C, B, D) {
            base2.DOM.Element.addEventListener(this, C, B, D)
            }
    }
    if ( ! A.hasClass) {
        A.hasClass = function(B) {
            if ((" " + this.className + " ").indexOf(" " + B + " ") !=- 1) {
                return true
            }
            return false
        }
    }
    if ( ! A.removeClass) {
        A.removeClass = function(B) {
            return base2.DOM.HTMLElement.removeClass(this, B)
            }
    }
    if ( ! A.addClass) {
        A.addClass = function(B) {
            return base2.DOM.HTMLElement.addClass(this, B)
            }
    }
};
wFORMS.applyBehaviors = function(D) {
    if ( !! base2.DOM.bind[D.base2ID] || window.opera || navigator.userAgent.match(/MSIE [567]/) || (navigator.userAgent.match(/MSIE 8/) && document.compatMode == "BackCompat")) {
        base2.DOM.bind(D)
        }
    if (wFORMS.behaviors["switch"]) {
        var A = wFORMS.behaviors["switch"].applyTo(D);
        if ( ! wFORMS.instances["switch"]) {
            wFORMS.instances["switch"] = [A]
            } else {
            wFORMS.removeBehavior(D, "switch");
            wFORMS.instances["switch"].push(A)
            }
    }
    for (var B in wFORMS.behaviors) {
        if (B == "switch") {
            continue
        }
        if (wFORMS.behaviors[B].applyTo) {
            var A = wFORMS.behaviors[B].applyTo(D);
            if (A && A.constructor != Array) {
                A = [A]
                }
            for (var C = 0; A && C < A.length; C ++ ) {
                if ( ! wFORMS.instances[B]) {
                    wFORMS.instances[B] = [A[C]]
                    } else {
                    wFORMS.removeBehavior(D, B);
                    wFORMS.instances[B].push(A[C])
                    }
            }
        }
    }
    if (wFORMS.behaviors.onApplyAll) {
        wFORMS.behaviors.onApplyAll(D)
        }
};
wFORMS.removeBehavior = function(C, A) {
    return null;
    if ( ! wFORMS.instances[A]) {
        return null
    }
    for (var B = 0; B < wFORMS.instances[A].length; B ++ ) {
        if (wFORMS.instances[A][B].target == C) {
            wFORMS.instances[A][B] = null
        }
    }
    return null
};
wFORMS.getBehaviorInstance = function(C, A) {
    if ( ! C ||! wFORMS.instances[A]) {
        return null
    }
    for (var B = 0; B < wFORMS.instances[A].length; B ++ ) {
        if (wFORMS.instances[A][B].target == C) {
            return wFORMS.instances[A][B]
            }
    }
    return null
};
base2.DOM.Element.addEventListener(document, "DOMContentLoaded", wFORMS.onLoadHandler, false);
wFORMS.helpers.activateStylesheet("wforms-jsonly.css");
if (navigator.userAgent.match(/iPad/i)) {
    wFORMS.helpers.activateStylesheet("wforms-layout-ipad.css")
    }
if (typeof(wFORMS) == "undefined") {
    throw new Error("wFORMS core not found. This behavior depends on the wFORMS core.")
    }
wFORMS.behaviors.hint = {
    CSS_INACTIVE: "field-hint-inactive",
    CSS_ACTIVE: "field-hint",
    HINT_SELECTOR: '*[id$="-H"]',
    HINT_SUFFIX: "-H",
    instance: function(A) {
        this.behavior = wFORMS.behaviors.hint;
        this.target = A
    }
};
wFORMS.behaviors.hint.applyTo = function(C) {
    var A = new wFORMS.behaviors.hint.instance(C);
    if ( ! C.querySelectorAll) {
        base2.DOM.bind(C)
        }
    var B = C.querySelectorAll(wFORMS.behaviors.hint.HINT_SELECTOR);
    if ( ! B.forEach) {
        B.forEach = NodeList.prototype.forEach
    }
    B.forEach(function(D) {
        var E = A.getElementByHintId(D.id);
        if (E) {
            if ( ! E.addEventListener) {
                base2.DOM.bind(E)
                }
            if (E.tagName == "SELECT" || E.tagName == "TEXTAREA" || (E.tagName == "INPUT" && E.type != "radio" && E.type != "checkbox")) {
                E.addEventListener("focus", function(F) {
                    A.run(F, this)
                    }, false);
                E.addEventListener("blur", function(F) {
                    A.run(F, this)
                    }, false)
                } else {
                E.addEventListener("mouseover", function(F) {
                    A.run(F, E)
                    }, false);
                E.addEventListener("mouseout", function(F) {
                    A.run(F, E)
                    }, false)
                }
        }
    });
    A.onApply();
    return A
};
wFORMS.behaviors.hint.instance.prototype.onApply = function() {};
wFORMS.behaviors.hint.instance.prototype.run = function(B, A) {
    var C = this.getHintElement(A);
    if ( ! C) {
        return
    }
    if ( ! C.removeClass) {
        base2.DOM.bind(C)
        }
    if (B.type == "focus" || B.type == "mouseover") {
        C.removeClass(wFORMS.behaviors.hint.CSS_INACTIVE);
        C.addClass(wFORMS.behaviors.hint.CSS_ACTIVE);
        if ( ! wFORMS.helpers.getForm(A).hasClass("hintsSide")) {
            this.setup(C, A)
            }
    } else {
        C.addClass(wFORMS.behaviors.hint.CSS_INACTIVE);
        C.removeClass(wFORMS.behaviors.hint.CSS_ACTIVE)
        }
};
wFORMS.behaviors.hint.instance.prototype.getElementByHintId = function(C) {
    var B = C.substr(0, C.length - wFORMS.behaviors.hint.HINT_SUFFIX.length);
    var A = document.getElementById(B);
    return A
};
wFORMS.behaviors.hint.instance.prototype.getHintElement = function(A) {
    var B = document.getElementById(A.id + this.behavior.HINT_SUFFIX);
    if (B &&! B.hasClass) {
        base2.DOM.bind(B)
        }
    return B && B != "" ? B: null
};
wFORMS.behaviors.hint.instance.prototype.setup = function(F, E) {
    var B = wFORMS.helpers.getForm(E);
    if (F.parentNode != B) {
        B.appendChild(F)
        }
    var A = wFORMS.helpers.position(E);
    var C = wFORMS.helpers.position(F);
    var D = {
        left: A.left - C.left,
        top: A.top - C.top
    };
    if (E.tagName.toLowerCase() == "select") {
        F.style.left = F.offsetLeft + D.left + E.offsetWidth + "px";
        F.style.top = F.offsetTop + D.top + "px"
    } else {
        F.style.left = F.offsetLeft + D.left + "px";
        F.style.top = F.offsetTop + D.top + E.offsetHeight + "px"
    }
};
wFORMS.behaviors.hint.isHintId = function(A) {
    return A.match(new RegExp(wFORMS.behaviors.hint.HINT_SUFFIX + "$")) != null
};
if (typeof(wFORMS) == "undefined") {
    throw new Error("wFORMS core not found. This behavior depends on the wFORMS core.")
    }
wFORMS.behaviors.paging = {
    SELECTOR: ".wfPage",
    CSS_PAGE: "wfPage",
    CSS_CURRENT_PAGE: "wfCurrentPage",
    CSS_BUTTON_NEXT: "wfPageNextButton",
    CSS_BUTTON_PREVIOUS: "wfPagePreviousButton",
    CSS_BUTTON_PLACEHOLDER: "wfPagingButtons",
    ID_BUTTON_NEXT_PREFIX: "wfPageNextId",
    ID_BUTTON_PREVIOUS_PREFIX: "wfPagePreviousId",
    CSS_SUBMIT_HIDDEN: "wfHideSubmit",
    ID_PAGE_PREFIX: "wfPgIndex-",
    ID_PLACEHOLDER_SUFFIX: "-buttons",
    ATTR_INDEX: "wfPageIndex_activate",
    MESSAGES: {
        CAPTION_NEXT: "Next Page",
        CAPTION_PREVIOUS: "Previous Page",
        CAPTION_UNLOAD: "Any data entered on ANY PAGE of this form will be LOST."
    },
    runValidationOnPageNext: true,
    warnOnUnload: true,
    onPageNext: function() {},
    onPagePrevious: function() {},
    onPageChange: function() {},
    instance: function(A) {
        this.behavior = wFORMS.behaviors.paging;
        this.target = A;
        this.currentPageIndex = 1
    }
};
wFORMS.behaviors.paging.applyTo = function(D) {
    var A = null;
    var C = wFORMS.behaviors.paging;
    var B = (wFORMS.behaviors.validation && wFORMS.behaviors.paging.runValidationOnPageNext);
    D.querySelectorAll(wFORMS.behaviors.paging.SELECTOR).forEach(function(G) {
        if ( ! A) {
            A = new wFORMS.behaviors.paging.instance(D)
            }
        var J = A.getOrCreatePlaceHolder(G);
        var E = wFORMS.behaviors.paging.getPageIndex(G);
        if (E == 1) {
            var H = base2.DOM.bind(J.appendChild(C._createNextPageButton(E)));
            if (B) {
                H.addEventListener("click", function(M) {
                    var L = wFORMS.getBehaviorInstance(A.target, "validation");
                    if (L.run(M, G)) {
                        A.run(M, H)
                        }
                }, false)
                } else {
                H.addEventListener("click", function(L) {
                    A.run(L, H)
                    }, false)
                }
            wFORMS.behaviors.paging.showPage(G)
            } else {
            var H = base2.DOM.bind(C._createPreviousPageButton(E));
            J.insertBefore(H, J.firstChild);
            H.addEventListener("click", function(L) {
                A.run(L, H)
                }, false);
            if ( ! wFORMS.behaviors.paging.isLastPageIndex(E, true)) {
                var F = base2.DOM.bind(J.appendChild(C._createNextPageButton(E)));
                if (B) {
                    F.addEventListener("click", function(M) {
                        var L = wFORMS.getBehaviorInstance(A.target, "validation");
                        if (L.run(M, G)) {
                            A.run(M, F)
                            }
                    }, false)
                    } else {
                    F.addEventListener("click", function(L) {
                        A.run(L, F)
                        }, false)
                    }
            }
        }
    });
    if (A) {
        p = A.findNextPage(0);
        A.currentPageIndex = 0;
        A.activatePage(wFORMS.behaviors.paging.getPageIndex(p), false);
        if ( ! window.onbeforeunload) {
            window.onbeforeunload = function() {
                if (A.behavior.warnOnUnload) {
                    return A.behavior.MESSAGES.CAPTION_UNLOAD
                }
            }
        }
        A.onApply();
        base2.DOM.Element.addEventListener(D, "submit", function(E) {
            A.onSubmit(E, A)
            })
        }
    return A
};
wFORMS.behaviors.paging.instance.prototype.onApply = function() {};
wFORMS.behaviors.paging.instance.prototype.onSubmit = function(E, A) {
    if ( ! wFORMS.behaviors.paging.isLastPageIndex(A.currentPageIndex)) {
        var D = wFORMS.behaviors.paging.getPageByIndex(A.currentPageIndex);
        var B = A.findNextPage(A.currentPageIndex);
        var C = wFORMS.getBehaviorInstance(A.target, "validation");
        if (C.run(E, D)) {
            A.activatePage(A.currentPageIndex + 1);
            var F = base2.DOM.Element.querySelector(B, "input, textarea, select");
            if (F) {
                F.focus()
                }
        }
        E.stopPropagation();
        E.preventDefault();
        E.pagingStopPropagation = true
    } else {
        if (window.onbeforeunload) {
            window.onbeforeunload = null
        }
    }
};
wFORMS.behaviors.paging.instance.prototype.onPageNext = function(A) {
    this.behavior.onPageNext(A)
    };
wFORMS.behaviors.paging.instance.prototype.onPagePrevious = function(A) {
    this.behavior.onPagePrevious(A)
    };
wFORMS.behaviors.paging.instance.prototype.onPageChange = function(A) {
    this.behavior.onPageChange(A)
    };
wFORMS.behaviors.paging.getPageIndex = function(B) {
    if (B && B.id) {
        var A = B.id.replace(new RegExp(wFORMS.behaviors.paging.ID_PAGE_PREFIX + "(\\d+)"), "$1");
        A = parseInt(A);
        return ! isNaN(A) ? A: false
    }
    return false
};
wFORMS.behaviors.paging.isElementVisible = function(A) {
    while (A && A.tagName != "BODY") {
        if (A.className) {
            if (A.className.indexOf(this.CSS_CURRENT_PAGE) !=- 1) {
                return true
            }
            if (A.className.indexOf(this.CSS_PAGE) !=- 1) {
                return false
            }
        }
        A = A.parentNode
    }
    return true
};
wFORMS.behaviors.paging._createNextPageButton = function(A) {
    var B = this.createNextPageButton();
    B.setAttribute(this.ATTR_INDEX, A + 1);
    B.id = this.ID_BUTTON_NEXT_PREFIX + A;
    return B
};
wFORMS.behaviors.paging.createNextPageButton = function() {
    var A = document.createElement("input");
    A.setAttribute("value", this.MESSAGES.CAPTION_NEXT);
    A.type = "button";
    A.className = this.CSS_BUTTON_NEXT;
    return A
};
wFORMS.behaviors.paging._createPreviousPageButton = function(A) {
    var B = this.createPreviousPageButton();
    B.setAttribute(this.ATTR_INDEX, A - 1);
    B.id = this.ID_BUTTON_PREVIOUS_PREFIX + A;
    return B
};
wFORMS.behaviors.paging.createPreviousPageButton = function() {
    var A = document.createElement("input");
    A.setAttribute("value", this.MESSAGES.CAPTION_PREVIOUS);
    A.type = "button";
    A.className = this.CSS_BUTTON_PREVIOUS;
    return A
};
wFORMS.behaviors.paging.instance.prototype.getOrCreatePlaceHolder = function(A) {
    var C = A.id + this.behavior.ID_PLACEHOLDER_SUFFIX;
    var B = document.getElementById(C);
    if ( ! B) {
        B = A.appendChild(document.createElement("div"));
        B.id = C;
        B.className = this.behavior.CSS_BUTTON_PLACEHOLDER
    }
    return B
};
wFORMS.behaviors.paging.hidePage = function(A) {
    if (A) {
        if ( ! A.removeClass) {
            A.removeClass = function(B) {
                return base2.DOM.HTMLElement.removeClass(this, B)
                }
        }
        if ( ! A.addClass) {
            A.addClass = function(B) {
                return base2.DOM.HTMLElement.addClass(this, B)
                }
        }
        A.removeClass(wFORMS.behaviors.paging.CSS_CURRENT_PAGE);
        A.addClass(wFORMS.behaviors.paging.CSS_PAGE)
        }
};
wFORMS.behaviors.paging.showPage = function(A) {
    if (A) {
        if ( ! A.removeClass) {
            A.removeClass = function(B) {
                return base2.DOM.HTMLElement.removeClass(this, B)
                }
        }
        A.removeClass(wFORMS.behaviors.paging.CSS_PAGE);
        if ( ! A.addClass) {
            A.addClass = function(B) {
                return base2.DOM.HTMLElement.addClass(this, B)
                }
        }
        A.addClass(wFORMS.behaviors.paging.CSS_CURRENT_PAGE)
        }
};
wFORMS.behaviors.paging.instance.prototype.activatePage = function(B) {
    if (arguments.length > 1) {
        var E = arguments[1]
        } else {
        var E = true
    }
    if (B == this.currentPageIndex) {
        return false
    }
    B = parseInt(B);
    if (B > this.currentPageIndex) {
        var C = this.findNextPage(this.currentPageIndex)
        } else {
        var C = this.findPreviousPage(this.currentPageIndex)
        }
    if (C) {
        var A = this;
        var B = A.behavior.getPageIndex(C);
        A.setupManagedControls(B);
        A.behavior.hidePage(A.behavior.getPageByIndex(A.currentPageIndex));
        A.behavior.showPage(C);
        var D = A.currentPageIndex;
        A.currentPageIndex = B;
        if (E) {
            if (C.scrollIntoView) {
                C.scrollIntoView()
                } else {
                location.hash = "#" + wFORMS.behaviors.paging.ID_PAGE_PREFIX + B
            }
        }
        A.onPageChange(C);
        if (B > D) {
            A.onPageNext(C)
            } else {
            A.onPagePrevious(C)
            }
    }
};
wFORMS.behaviors.paging.instance.prototype.setupManagedControls = function(B) {
    if ( ! B) {
        B = this.currentPageIndex
    }
    var A = wFORMS.behaviors.paging;
    if (A.isFirstPageIndex(B)) {
        if (ctrl = A.getPreviousButton(B)) {
            ctrl.style.visibility = "hidden"
        }
    } else {
        if (ctrl = A.getPreviousButton(B)) {
            ctrl.style.visibility = "visible"
        }
    }
    if (A.isLastPageIndex(B)) {
        if (ctrl = A.getNextButton(B)) {
            ctrl.style.visibility = "hidden"
        }
        this.showSubmitButtons()
        } else {
        if (ctrl = A.getNextButton(B)) {
            ctrl.style.visibility = "visible"
        }
        this.hideSubmitButtons()
        }
};
wFORMS.behaviors.paging.instance.prototype.showSubmitButtons = function() {
    var A = this.target.getElementsByTagName("input");
    for (var B = 0; B < A.length; B ++ ) {
        if (A[B].type == "submit") {
            A[B].className = A[B].className.replace(new RegExp("(^|\\s)" + this.behavior.CSS_SUBMIT_HIDDEN + "(\\s|$)", "g"), "$2")
            }
    }
};
wFORMS.behaviors.paging.instance.prototype.hideSubmitButtons = function() {
    var A = this.target.getElementsByTagName("input");
    for (var B = 0; B < A.length; B ++ ) {
        if (A[B].type == "submit") {
            if ( ! (new RegExp("(^|\\s)" + this.behavior.CSS_SUBMIT_HIDDEN + "(\\s|$)")).test(A[B].className)) {
                A[B].className += " " + this.behavior.CSS_SUBMIT_HIDDEN
            }
        }
    }
};
wFORMS.behaviors.paging.getPageByIndex = function(A) {
    var B = document.getElementById(wFORMS.behaviors.paging.ID_PAGE_PREFIX + A);
    return B ? base2.DOM.bind(B): false
};
wFORMS.behaviors.paging.getNextButton = function(A) {
    return document.getElementById(wFORMS.behaviors.paging.ID_BUTTON_NEXT_PREFIX + A)
    };
wFORMS.behaviors.paging.getPreviousButton = function(A) {
    return document.getElementById(wFORMS.behaviors.paging.ID_BUTTON_PREVIOUS_PREFIX + A)
    };
wFORMS.behaviors.paging.isLastPageIndex = function(C, B) {
    C = parseInt(C) + 1;
    var A = wFORMS.behaviors.paging;
    var D = A.getPageByIndex(C);
    if ((_b = wFORMS.behaviors["switch"]) &&! B) {
        while (D && _b.isSwitchedOff(D)) {
            C ++ ;
            D = A.getPageByIndex(C)
            }
    }
    return D ? false: true
};
wFORMS.behaviors.paging.isFirstPageIndex = function(C, B) {
    C = parseInt(C) - 1;
    var A = wFORMS.behaviors.paging;
    var D = A.getPageByIndex(C);
    if ((_b = wFORMS.behaviors["switch"]) &&! B) {
        while (D && _b.isSwitchedOff(D)) {
            C -- ;
            D = A.getPageByIndex(C)
            }
    }
    return D ? false: true
};
wFORMS.behaviors.paging.instance.prototype.findNextPage = function(B) {
    B = parseInt(B) + 1;
    var A = wFORMS.behaviors.paging;
    var C = A.getPageByIndex(B);
    if (_b = wFORMS.behaviors["switch"]) {
        while (C && _b.isSwitchedOff(C)) {
            B ++ ;
            C = A.getPageByIndex(B)
            }
    }
    return C
};
wFORMS.behaviors.paging.instance.prototype.findPreviousPage = function(B) {
    B = parseInt(B) - 1;
    var A = wFORMS.behaviors.paging;
    var C = A.getPageByIndex(B);
    if (_b = wFORMS.behaviors["switch"]) {
        while (C && _b.isSwitchedOff(C)) {
            B -- ;
            C = A.getPageByIndex(B)
            }
    }
    return C ? C: false
};
wFORMS.behaviors.paging.instance.prototype.run = function(B, A) {
    this.activatePage(A.getAttribute(wFORMS.behaviors.paging.ATTR_INDEX))
    };
if (typeof(wFORMS) == "undefined") {
    throw new Error("wFORMS core not found. This behavior depends on the wFORMS core.")
    }
wFORMS.behaviors.repeat = {
    SELECTOR_REPEAT: '*[class~="repeat"]',
    SELECTOR_REMOVEABLE: '*[class~="removeable"]',
    ID_SUFFIX_DUPLICATE_LINK: "-wfDL",
    ID_SUFFIX_COUNTER: "-RC",
    CSS_DUPLICATE_LINK: "duplicateLink",
    CSS_DUPLICATE_SPAN: "duplicateSpan",
    CSS_DELETE_LINK: "removeLink",
    CSS_DELETE_SPAN: "removeSpan",
    CSS_REMOVEABLE: "removeable",
    CSS_REPEATABLE: "repeat",
    ATTR_DUPLICATE: "wfr__dup",
    ATTR_DUPLICATE_ELEM: "wfr__dup_elem",
    ATTR_HANDLED: "wfr_handled",
    ATTR_MASTER_SECTION: "wfr__master_sec",
    ATTR_LINK_SECTION_ID: "wfr_sec_id",
    MESSAGES: {
        ADD_CAPTION: "Add another response",
        ADD_TITLE: "Will duplicate this question or section.",
        REMOVE_CAPTION: "Remove",
        REMOVE_TITLE: "Will remove this question or section"
    },
    UPDATEABLE_ATTR_ARRAY: ["id", "name", "for"],
    preserveRadioName: false,
    CSS_PRESERVE_RADIO_NAME: "preserveRadioName",
    onRepeat: function(A) {},
    onRemove: function(A) {},
    allowRepeat: function(B, A) {
        return true
    },
    instance: function(A) {
        this.behavior = wFORMS.behaviors.repeat;
        this.target = A
    }
};
var _b = wFORMS.behaviors.repeat;
var _i = wFORMS.behaviors.repeat.instance;
_b.applyTo = function(F) {
    var C = this;
    var B = new Array();
    if ( !! base2.DOM.bind[F.base2ID]) {
        base2.DOM.bind(F)
        }
    F.querySelectorAll(this.SELECTOR_REPEAT).forEach(function(H) {
        if (C.isHandled(H)) {
            return
        }
        if ( ! H.id) {
            H.id = wFORMS.helpers.randomId()
            }
        var G = new C.instance(H);
        var J = G.getOrCreateRepeatLink(H);
        J.addEventListener("click", function(L) {
            G.run(L, J)
            }, false);
        G.setElementHandled(H);
        B.push(G)
        });
    if ( ! F.hasClass) {
        F.hasClass = function(G) {
            return base2.DOM.HTMLElement.hasClass(this, G)
            }
    }
    if (F.hasClass(this.CSS_REMOVEABLE)) {
        var A = this.getMasterSection(F);
        var E = wFORMS.getBehaviorInstance(A, "repeat");
        if (E) {
            E.getOrCreateRemoveLink(F)
            } else {
            if (B[0]) {
                B[0].getOrCreateRemoveLink(F)
                }
        }
    }
    F.querySelectorAll(this.SELECTOR_REMOVEABLE).forEach(function(J) {
        var G = wFORMS.behaviors.repeat.getMasterSection(J);
        var H = wFORMS.getBehaviorInstance(G, "repeat");
        if (H) {
            H.getOrCreateRemoveLink(J)
            } else {
            if (B[0]) {
                B[0].getOrCreateRemoveLink(J)
                }
        }
    });
    for (var D = 0; D < B.length; D ++ ) {
        B[D].onApply()
        }
    return B
};
_i.prototype.onApply = function() {};
_i.prototype.getOrCreateRepeatLink = function(C) {
    var E = C.id + this.behavior.ID_SUFFIX_DUPLICATE_LINK;
    var D = document.getElementById(E);
    if ( ! D || D == "") {
        D = this.createRepeatLink(E);
        var A = document.createElement("span");
        A.className = this.behavior.CSS_DUPLICATE_SPAN;
        D = A.appendChild(D);
        if (C.tagName.toUpperCase() == "TR") {
            var B = C.getElementsByTagName("TD");
            if ( ! B) {
                B = C.appendChild(document.createElement("TD"))
                } else {
                B = B[B.length - 1]
                }
            B.appendChild(A)
            } else {
            C.appendChild(A)
            }
    }
    return base2.DOM.bind(D)
    };
_i.prototype.createRepeatLink = function(B) {
    var A = document.createElement("A");
    A.id = B;
    A.setAttribute("href", "#");
    A.className = this.behavior.CSS_DUPLICATE_LINK;
    A.setAttribute("title", this.behavior.MESSAGES.ADD_TITLE);
    A.appendChild(document.createElement("span").appendChild(document.createTextNode(this.behavior.MESSAGES.ADD_CAPTION)));
    return A
};
_i.prototype.getOrCreateRemoveLink = function(C) {
    var D = this.createRemoveLink(C.id);
    if (C.tagName == "TR") {
        var B = C.getElementsByTagName("TD");
        var A = B[B.length - 1];
        A.appendChild(D)
        } else {
        C.appendChild(D)
        }
};
_i.prototype.createRemoveLink = function(D) {
    var B = document.createElement("a");
    B.id = D + this.behavior.ID_SUFFIX_DUPLICATE_LINK;
    B.setAttribute("href", "#");
    B.className = this.behavior.CSS_DELETE_LINK;
    B.setAttribute("title", this.behavior.MESSAGES.REMOVE_TITLE);
    B.setAttribute(this.behavior.ATTR_LINK_SECTION_ID, D);
    var C = document.createElement("span");
    C.appendChild(document.createTextNode(this.behavior.MESSAGES.REMOVE_CAPTION));
    B.appendChild(C);
    var A = this;
    B.onclick = function(E) {
        A.onRemoveLinkClick(E, B);
        return false
    };
    var C = document.createElement("span");
    C.className = this.behavior.CSS_DELETE_SPAN;
    C.appendChild(B);
    return C
};
_i.prototype.duplicateSection = function(C) {
    if ( ! this.behavior.allowRepeat(C, this)) {
        return false
    }
    this.updateMasterSection(C);
    var B = C.cloneNode(true);
    var A = this.getNextDuplicateIndex(this.target);
    var D = this.createSuffix(C, A);
    this.updateDuplicatedSection(B, A, D);
    B = C.parentNode.insertBefore(B, this.getInsertNode(C));
    wFORMS.applyBehaviors(B);
    this.behavior.onRepeat(B);
    wFORMS.helpers.spotlight(B)
    };
_i.prototype.removeSection = function(A) {
    if (A) {
        var A = A.parentNode.removeChild(A);
        this.behavior.onRemove(A)
        }
};
_i.prototype.getInsertNode = function(B) {
    var A = B.nextSibling;
    if (A && A.nodeType == 1 &&! A.hasClass) {
        A.hasClass = function(C) {
            return base2.DOM.HTMLElement.hasClass(this, C)
            }
    }
    while (A && (A.nodeType == 3 || A.hasClass(this.behavior.CSS_REMOVEABLE))) {
        A = A.nextSibling;
        if (A && A.nodeType == 1 &&! A.hasClass) {
            A.hasClass = function(C) {
                return base2.DOM.HTMLElement.hasClass(this, C)
                }
        }
    }
    return A
};
_i.prototype.onRemoveLinkClick = function(B, A) {
    var C = document.getElementById(A.getAttribute(this.behavior.ATTR_LINK_SECTION_ID));
    this.removeSection(C);
    if (B) {
        B.preventDefault()
        }
};
_i.prototype.updateMasterSection = function(A) {
    if (A.doItOnce == true) {
        return true
    } else {
        A.doItOnce = true
    }
    var B = this.createSuffix(A);
    A.id = this.clearSuffix(A.id) + B;
    this.updateMasterElements(A, B)
    };
_i.prototype.updateMasterElements = function(B, J) {
    if ( ! B || B.nodeType != 1) {
        return
    }
    var G = B.childNodes;
    for (var E = 0; E < G.length; E ++ ) {
        var A = G[E];
        if (A.nodeType != 1) {
            continue
        }
        if ( ! A.hasClass) {
            A.hasClass = function(L) {
                return base2.DOM.HTMLElement.hasClass(this, L)
                }
        }
        var C = J;
        if (A.hasClass(this.behavior.CSS_REPEATABLE)) {
            J += "[0]"
        }
        if ( ! A.hasClass(this.behavior.CSS_REMOVEABLE)) {
            for (var D = 0; D < this.behavior.UPDATEABLE_ATTR_ARRAY.length; D ++ ) {
                var F = this.behavior.UPDATEABLE_ATTR_ARRAY[D];
                var H = this.clearSuffix(A.getAttribute(F));
                if ( ! H) {
                    continue
                }
                if (F == "id" && wFORMS.behaviors.hint && wFORMS.behaviors.hint.isHintId(A.id)) {
                    A.id = H.replace(new RegExp("(.*)(" + wFORMS.behaviors.hint.HINT_SUFFIX + ")$"), "$1" + J + "$2")
                    } else {
                    if (F == "id" && wFORMS.behaviors.validation && wFORMS.behaviors.validation.isErrorPlaceholderId(A.id)) {
                        A.id = H.replace(new RegExp("(.*)(" + wFORMS.behaviors.validation.ERROR_PLACEHOLDER_SUFFIX + ")$"), "$1" + J + "$2")
                        } else {
                        if (F == "id" && A.id.indexOf(this.behavior.ID_SUFFIX_DUPLICATE_LINK) !=- 1) {
                            A.id = H.replace(new RegExp("(.*)(" + this.behavior.ID_SUFFIX_DUPLICATE_LINK + ")$"), "$1" + J + "$2")
                            } else {
                            if (F == "id") {
                                A.id = H + J
                            } else {
                                if (F == "name") {
                                    A.name = H + J
                                } else {
                                    A.setAttribute(F, H + J)
                                    }
                            }
                        }
                    }
                }
            }
            this.updateMasterElements(A, J)
            }
        J = C
    }
};
_i.prototype.updateDuplicatedSection = function(C, A, D) {
    C[this.behavior.ATTR_MASTER_SECTION] = C.id;
    C.id = this.clearSuffix(C.id) + D;
    C.className = C.className.replace(this.behavior.CSS_REPEATABLE, this.behavior.CSS_REMOVEABLE);
    if ( ! C.hasClass) {
        C.hasClass = function(E) {
            return base2.DOM.HTMLElement.hasClass(this, E)
            }
    }
    if (C.hasClass(this.behavior.CSS_PRESERVE_RADIO_NAME)) {
        var B = true
    } else {
        var B = this.behavior.preserveRadioName
    }
    this.updateSectionChildNodes(C, D, B)
    };
_i.prototype.updateSectionChildNodes = function(elem, suffix, preserveRadioName) {
    if (elem.doItOnce) {
        elem.doItOnce = null
    }
    var removeStack = new Array();
    var i = 0;
    while (elem && elem.childNodes && elem.childNodes[i]) {
        var e = elem.childNodes[i];
        i ++ ;
        if (e.nodeType != 1) {
            continue
        }
        if ( ! e.hasClass) {
            e.hasClass = function(className) {
                return base2.DOM.HTMLElement.hasClass(this, className)
                }
        }
        if (this.behavior.isDuplicate(e)) {
            removeStack.push(e);
            continue
        }
        if (e.hasClass(this.behavior.CSS_DUPLICATE_SPAN)) {
            removeStack.push(e);
            continue
        }
        if (e.hasClass(this.behavior.CSS_DUPLICATE_LINK)) {
            removeStack.push(e);
            continue
        }
        if ((e.tagName == "INPUT" && e.type != "button") || e.tagName == "TEXTAREA") {
            if (e.type != "radio" && e.type != "checkbox") {
                e.value = ""
            } else {
                e.checked = false
            }
        }
        if (e.tagName == "INPUT" && e.type == "radio" &&! preserveRadioName && 
/*@cc_on @if(@_jscript_version < 5.8)! @end @*/
        false) {
            var tagHtml = '<INPUT type="radio" name="' + e.name + suffix + '"></INPUT>';
            var fixedRadio = e.parentNode.insertBefore(document.createElement(tagHtml), e);
            fixedRadio.id = e.id;
            fixedRadio.className = e.className;
            fixedRadio.value = e.value;
            e = e.parentNode.removeChild(e);
            var l = this.behavior.UPDATEABLE_ATTR_ARRAY.length;
            for (var j = 0; j < l; j ++ ) {
                var attrName = this.behavior.UPDATEABLE_ATTR_ARRAY[j];
                var value = e.getAttribute(attrName);
                fixedRadio.setAttribute(attrName, value)
                }
            e = fixedRadio;
            if ( ! e.hasClass) {
                e.hasClass = function(className) {
                    return base2.DOM.HTMLElement.hasClass(this, className)
                    }
            }
        }
        this.updateAttributes(e, suffix, preserveRadioName);
        if (e.hasClass(this.behavior.CSS_REPEATABLE)) {
            this.updateSectionChildNodes(e, this.createSuffix(e), preserveRadioName)
            } else {
            this.updateSectionChildNodes(e, suffix, preserveRadioName)
            }
    }
    for (var i = 0; i < removeStack.length; i ++ ) {
        var e = removeStack[i];
        if (e.clearAttributes) {
            e.clearAttributes(false)
            }
        if (e.parentNode) {
            e.parentNode.removeChild(e)
            }
    }
};
_i.prototype.createSuffix = function(E, B) {
    var D = "[" + (B ? B: "0") + "]";
    var C = /\[(\d+)\]$/;
    E = E.parentNode;
    while (E && E.tagName) {
        if ( ! E.hasClass) {
            E.hasClass = function(F) {
                return base2.DOM.HTMLElement.hasClass(this, F)
                }
        }
        if (E.hasClass(this.behavior.CSS_REPEATABLE) || E.hasClass(this.behavior.CSS_REMOVEABLE)) {
            var A = C.exec(E.id);
            if (A) {
                A = A[1]
                }
            D = "[" + (A ? A: "0") + "]" + D
        }
        E = E.parentNode
    }
    return D
};
_i.prototype.clearSuffix = function(A) {
    if ( ! A) {
        return
    }
    A = A.replace(/(\[\d+\])+(\-[HE])?$/, "$2");
    return A
};
_i.prototype.updateAttributes = function(F, D, H) {
    var L = wFORMS.behaviors.hint && wFORMS.behaviors.hint.isHintId(F.id);
    var C = wFORMS.behaviors.validation && wFORMS.behaviors.validation.isErrorPlaceholderId(F.id);
    var B = F.id.indexOf(this.behavior.ID_SUFFIX_DUPLICATE_LINK) !=- 1;
    this.setInDuplicateGroup(F);
    if (this.behavior.isHandled(F)) {
        this.removeHandled(F)
        }
    if (wFORMS.behaviors["switch"] && wFORMS.behaviors["switch"].isHandled(F)) {
        wFORMS.behaviors["switch"].removeHandle(F)
        }
    if (wFORMS.behaviors["calculation"] && wFORMS.behaviors["calculation"].isHandled(F)) {
        wFORMS.behaviors["calculation"].removeHandledFlag(F)
        }
    var A = this.behavior.UPDATEABLE_ATTR_ARRAY.length;
    for (var E = 0; E < A; E ++ ) {
        var G = this.behavior.UPDATEABLE_ATTR_ARRAY[E];
        var J = this.clearSuffix(F.getAttribute(G));
        if ( ! J) {
            continue
        }
        if (G == "name" && F.tagName == "INPUT" && H) {
            continue
        } else {
            if (C && G == "id") {
                F.id = J.replace(new RegExp("(.*)(" + wFORMS.behaviors.validation.ERROR_PLACEHOLDER_SUFFIX + ")$"), "$1" + D + "$2")
                } else {
                if (L && G == "id") {
                    F.id = J.replace(new RegExp("(.*)(" + wFORMS.behaviors.hint.HINT_SUFFIX + ")$"), "$1" + D + "$2")
                    } else {
                    if (B && G == "id") {
                        F.id = J.replace(new RegExp("(.*)(" + this.behavior.ID_SUFFIX_DUPLICATE_LINK + ")$"), "$1" + D + "$2")
                        } else {
                        if (G == "id") {
                            F.id = J + D
                        } else {
                            if (G == "name") {
                                F.name = J + D
                            } else {
                                F.setAttribute(G, J + D)
                                }
                        }
                    }
                }
            }
        }
    }
};
_i.prototype.getNextDuplicateIndex = function(A) {
    var C = this.getOrCreateCounterField(A);
    var B = parseInt(C.value) + 1;
    C.value = B;
    return B
};
_i.prototype.getOrCreateCounterField = function(C) {
    var A = C.id + this.behavior.ID_SUFFIX_COUNTER;
    var B = document.getElementById(A);
    if ( ! B || B == "") {
        B = this.createCounterField(A);
        var D = C.parentNode;
        while (D && D.tagName.toUpperCase() != "FORM") {
            D = D.parentNode
        }
        D.appendChild(B)
        }
    return B
};
_i.prototype.createCounterField = function(A) {
    cElem = document.createElement("input");
    cElem.id = A;
    cElem.setAttribute("type", "hidden");
    cElem.setAttribute("name", A);
    cElem.value = "0";
    return cElem
};
_i.prototype.getSectionsCount = function() {
    if (this.behavior.isDuplicate(this.target)) {
        return false
    }
    return parseInt(this.getOrCreateCounterField(this.target).value) + 1
};
_i.prototype.setInDuplicateGroup = function(A) {
    return A.setAttribute(this.behavior.ATTR_DUPLICATE_ELEM, true)
    };
_i.prototype.setElementHandled = function(A) {
    return A.setAttribute(this.behavior.ATTR_HANDLED, true)
    };
_i.prototype.removeHandled = function(A) {
    return A.removeAttribute(this.behavior.ATTR_HANDLED)
    };
_b.isDuplicate = function(A) {
    if ( ! A.hasClass) {
        A.hasClass = function(B) {
            return base2.DOM.HTMLElement.hasClass(this, B)
            }
    }
    return A.hasClass(this.CSS_REMOVEABLE)
    };
_b.isInDuplicateGroup = function(A) {
    return A.getAttribute(this.ATTR_DUPLICATE_ELEM) ? true: false
};
_b.isHandled = function(A) {
    return A.getAttribute(this.ATTR_HANDLED)
    };
_b.getMasterSection = function(A) {
    if ( ! this.isDuplicate(A)) {
        return false
    }
    return document.getElementById(A[this.ATTR_MASTER_SECTION])
    };
_i.prototype.run = function(B) {
    if ( ! wFORMS.LOADER.enabled) {
        this.duplicateSection(this.target)
        } else {
        var A = this;
        wFORMS.LOADER.show(A.target);
        setTimeout(function() {
            A.duplicateSection(A.target);
            wFORMS.LOADER.hide(A.target, true)
            }, 1)
        }
    if (B) {
        B.preventDefault()
        }
};
if (typeof(wFORMS) == "undefined") {
    throw new Error("wFORMS core not found. This behavior depends on the wFORMS core.")
    }
wFORMS.behaviors["switch"] = {
    SELECTOR: '*[class*="switch-"]',
    CSS_PREFIX: "switch-",
    CSS_OFFSTATE_PREFIX: "offstate-",
    CSS_ONSTATE_PREFIX: "onstate-",
    CSS_ONSTATE_FLAG: "swtchIsOn",
    CSS_OFFSTATE_FLAG: "swtchIsOff",
    onSwitchOn: function(A) {},
    onSwitchOff: function(A) {},
    onSwitch: function(A) {},
    instance: function(A) {
        this.behavior = wFORMS.behaviors["switch"];
        this.target = A;
        this.cache = {}
    }
};
wFORMS.behaviors["switch"].applyTo = function(C) {
    var A = new wFORMS.behaviors["switch"].instance(C);
    A.buildCache();
    if (A.isCacheEmpty()) {
        A.onApply();
        return A
    }
    A.setupTriggers();
    if (C.tagName != "FORM") {
        while (C && C.tagName != "FORM") {
            C = C.parentNode
        }
        var B = wFORMS.getBehaviorInstance(C, "switch");
        if (B) {
            B.merge(A);
            A.cache = B.cache;
            A.setupTargets();
            A.onApply();
            return new Array( {
                target: null
            })
            }
    }
    A.setupTargets();
    A.onApply();
    return A
};
wFORMS.behaviors["switch"].instance.prototype.setupTriggers = function() {
    for (var B in this.cache) {
        var C = this.cache[B].triggers;
        for (var A = 0; A < C.length; A ++ ) {
            this.setupTrigger(C[A])
            }
    }
};
wFORMS.behaviors["switch"].instance.prototype.setupTrigger = function(G) {
    var C = this;
    if ( ! G.id) {
        G.id = wFORMS.helpers.randomId()
        }
    switch(G.tagName.toUpperCase()) {
        case "OPTION": var A = G.parentNode;
        while (A && A.tagName != "SELECT") {
            A = A.parentNode
        }
        if (A &&! wFORMS.behaviors["switch"].isHandled(A)) {
            A.addEventListener("change", function(J) {
                C.run(J, A)
                }, false);
            wFORMS.behaviors["switch"].handleElement(A)
            }
        break;
        case "SELECT": if (G &&! wFORMS.behaviors["switch"].isHandled(G)) {
            G.addEventListener("change", function(J) {
                C.run(J, G)
                }, false);
            wFORMS.behaviors["switch"].handleElement(G)
            }
        break;
        case "INPUT": if (G.type && G.type.toUpperCase() == "RADIO") {
            var D = G.form[G.name];
            if ( ! D) {
                D = [];
                var H = G.form.getElementsByTagName("INPUT");
                for (var B = 0; B < H.length; B ++ ) {
                    if (H[B].type == "radio" && H[B].name == G.name) {
                        D.push(H[B])
                        }
                }
            }
            for (var F = D.length - 1; F >= 0; F -- ) {
                var E = D[F];
                wFORMS.standardizeElement(E);
                if ( ! this.behavior.isHandled(E)) {
                    E.addEventListener("click", function(J) {
                        C.run(J, E)
                        }, false);
                    this.behavior.handleElement(E)
                    }
            }
        } else {
            if (G.type && G.type == "checkbox") {
                if ( ! this.behavior.isHandled(G)) {
                    G.addEventListener("click", function(J) {
                        C.run(J, G)
                        }, false);
                    this.behavior.handleElement(G)
                    }
            }
        }
        break;
        default: if ( ! this.behavior.isHandled(G)) {
            G.addEventListener("click", function(J) {
                C.run(J, G)
                }, false);
            this.behavior.handleElement(G)
            }
        break
    }
};
wFORMS.behaviors["switch"].instance.prototype.onApply = function() {};
wFORMS.behaviors["switch"].isHandled = function(A) {
    return A.getAttribute("rel") && A.getAttribute("rel").indexOf("wfHandled") >- 1
};
wFORMS.behaviors["switch"].handleElement = function(A) {
    return A.setAttribute("rel", (A.getAttribute("rel") || "") + " wfHandled")
    };
wFORMS.behaviors["switch"].removeHandle = function(A) {
    if (attr = A.getAttribute("rel")) {
        if (attr == "wfHandled") {
            A.removeAttribute("rel")
            } else {
            if (attr.indexOf("wfHandled") !=- 1) {
                A.setAttribute("rel", attr.replace(/(.*)( wfHandled)(.*)/, "$1$3"))
                }
        }
    }
};
wFORMS.behaviors["switch"].instance.prototype.buildCache = function() {
    this.cache_processed = new Array();
    if (this.target.className) {
        if (this.target.className.indexOf(this.behavior.CSS_PREFIX) !=- 1) {
            this.addTriggerToCache(this.target)
            }
        if (this.target.className.indexOf(this.behavior.CSS_OFFSTATE_PREFIX) !=- 1) {
            this.addTargetToCache(this.target)
            }
        if (this.target.className.indexOf(this.behavior.CSS_ONSTATE_PREFIX) !=- 1) {
            this.addTargetToCache(this.target)
            }
    }
    var A = this.target.getElementsByTagName("*");
    for (var B = 0; B < A.length; B ++ ) {
        if (A[B].tagName) {
            if (A[B].className) {
                if (A[B].className.indexOf(this.behavior.CSS_PREFIX) !=- 1) {
                    this.addTriggerToCache(A[B])
                    }
                if (A[B].className.indexOf(this.behavior.CSS_OFFSTATE_PREFIX) !=- 1) {
                    this.addTargetToCache(A[B])
                    }
                if (A[B].className.indexOf(this.behavior.CSS_ONSTATE_PREFIX) !=- 1) {
                    this.addTargetToCache(A[B])
                    }
            }
        }
    }
};
wFORMS.behaviors["switch"].instance.prototype.merge = function(A) {
    for (var D in A.cache) {
        if ( ! this.cache[D]) {
            this.cache[D] = A.cache[D];
            continue
        }
        for (var C = 0; C < A.cache[D].triggers.length; C ++ ) {
            for (var B = 0; B < this.cache[D].triggers.length && A.cache[D].triggers[C] != this.cache[D].triggers[B]; B ++ ) {}
            if (B == this.cache[D].triggers.length) {
                this.cache[D].triggers.push(A.cache[D].triggers[C])
                }
        }
        for (var C = 0; C < A.cache[D].targets.length; C ++ ) {
            for (var B = 0; B < this.cache[D].targets.length && A.cache[D].targets[C] != this.cache[D].targets[B]; B ++ ) {}
            if (B == this.cache[D].targets.length) {
                this.cache[D].targets.push(A.cache[D].targets[C])
                }
        }
    }
    for (var D = 0; D < A.cache_processed.length; D ++ ) {
        for (var C = 0; C < this.cache_processed.length && this.cache_processed[C] != A.cache_processed[D]; C ++ ) {}
        if (C == this.cache_processed.length) {
            this.cache_processed.push(A.cache_processed[D])
            }
    }
};
wFORMS.behaviors["switch"].instance.prototype.isCacheEmpty = function() {
    for (var A in this.cache) {
        return false
    }
    return true
};
wFORMS.behaviors["switch"].instance.prototype.invalidateCache = function() {
    var D = true;
    if (arguments.length > 0) {
        var C = document.getElementById(arguments[0]);
        if (C) {
            var D = false;
            if ( ! C.querySelectorAll) {
                base2.DOM.bind(C)
                }
            var A = '*[class*="' + this.behavior.CSS_PREFIX + '"], *[class*="' + this.behavior.CSS_OFFSTATE_PREFIX + '"], *[class*="' + this.behavior.CSS_ONSTATE_PREFIX + '"]';
            var B = C.querySelectorAll(A);
            if (B.length > 0 || C.className && (C.className.indexOf(this.behavior.CSS_PREFIX) !=- 1 || C.className.indexOf(this.behavior.CSS_OFFSTATE_PREFIX) !=- 1 || C.className.indexOf(this.behavior.CSS_ONSTATE_PREFIX) !=- 1)) {
                D = true
            }
        }
    }
    if (D) {
        this.cache = {};
        this.buildCache()
        }
};
wFORMS.behaviors["switch"].instance.prototype.addTriggerToCache = function(F) {
    if (F.tagName == "OPTION") {
        var A = F.parentNode;
        while (A && A.tagName != "SELECT") {
            A = A.parentNode
        }
        if ( ! A) {
            return
        }
        F = A
    }
    if ( ! F.id) {
        F.id = wFORMS.helpers.randomId()
        }
    for (var C = 0; C < this.cache_processed.length; C ++ ) {
        if (this.cache_processed[C] == F.id) {
            return
        }
    }
    this.cache_processed.push(F.id);
    wFORMS.standardizeElement(F);
    var E = this.getTriggers(new Array(F));
    for (var D = 0; D < E.ON.length; D ++ ) {
        var B = E.ON[D];
        if (typeof this.cache[B] == "undefined") {
            this.cache[B] = {
                triggers: [],
                targets: []
                }
        }
        for (var C = 0; C < this.cache[B].triggers.length; C ++ ) {
            if (this.cache[B].triggers[C] == F) {
                break
            }
        }
        if (C == this.cache[B].triggers.length) {
            this.cache[B].triggers.push(F)
            }
    }
    for (var D = 0; D < E.OFF.length; D ++ ) {
        var B = E.OFF[D];
        if (typeof this.cache[B] == "undefined") {
            this.cache[B] = {
                triggers: [],
                targets: []
                }
        }
        for (var C = 0; C < this.cache[B].triggers.length; C ++ ) {
            if (this.cache[B].triggers[C] == F) {
                break
            }
        }
        if (C == this.cache[B].triggers.length) {
            this.cache[B].triggers.push(F)
            }
    }
};
wFORMS.behaviors["switch"].instance.prototype.addTargetToCache = function(C) {
    wFORMS.standardizeElement(C);
    var D = this.behavior.getSwitchNamesFromTarget(C);
    for (var B = 0; B < D.length; B ++ ) {
        switchName = D[B];
        if (typeof this.cache[switchName] == "undefined") {
            this.cache[switchName] = {
                triggers: [],
                targets: []
                }
        }
        for (var A = 0; A < this.cache[switchName].targets.length; A ++ ) {
            if (this.cache[switchName].targets[A] == C) {
                break
            }
        }
        if (A == this.cache[switchName].targets.length) {
            this.cache[switchName].targets.push(C)
            }
    }
};
wFORMS.behaviors["switch"].instance.prototype.getTriggers = function(A, M) {
    var C = {
        ON: new Array(),
        OFF: new Array(),
        toString: function() {
            return "ON: " + this.ON + "\nOFF: " + this.OFF
        }
    };
    for (var H = 0; H < A.length; H ++ ) {
        var D = A[H];
        switch(D.tagName.toUpperCase()) {
            case "OPTION": if (D.selected) {
                C.ON = C.ON.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                } else {
                C.OFF = C.OFF.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                }
            break;
            case "SELECT": for (var F = 0; F < D.options.length; F ++ ) {
                var B = D.options.item(F);
                if (B.selected) {
                    C.ON = C.ON.concat(this.behavior.getSwitchNamesFromTrigger(B, M))
                    } else {
                    C.OFF = C.OFF.concat(this.behavior.getSwitchNamesFromTrigger(B, M))
                    }
            }
            break;
            case "INPUT": if (D.type && D.type.toUpperCase() == "RADIO" && D.form) {
                var G = D.form[D.name];
                if ( ! G) {
                    var G = [];
                    var J = D.form.getElementsByTagName("INPUT");
                    for (var E = 0; E < J.length; E ++ ) {
                        if (J[E].type == "radio" && J[E].name == D.name) {
                            G.push(J[E])
                            }
                    }
                }
                for (var F = G.length - 1; F >= 0; F -- ) {
                    var O = G[F];
                    if (O == D ||! wFORMS.helpers.contains(A, O)) {
                        if (O.checked) {
                            C.ON = C.ON.concat(this.behavior.getSwitchNamesFromTrigger(O, M))
                            } else {
                            C.OFF = C.OFF.concat(this.behavior.getSwitchNamesFromTrigger(O, M))
                            }
                    }
                }
            } else {
                if (D.type && D.type == "checkbox") {
                    if (D.checked) {
                        C.ON = C.ON.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                        } else {
                        C.OFF = C.OFF.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                        }
                } else {
                    if (D.hasClass(this.behavior.CSS_ONSTATE_FLAG)) {
                        C.ON = C.ON.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                        } else {
                        C.OFF = C.OFF.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                        }
                }
            }
            break;
            default: if (D.hasClass(this.behavior.CSS_ONSTATE_FLAG)) {
                C.ON = C.ON.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                } else {
                C.OFF = C.OFF.concat(this.behavior.getSwitchNamesFromTrigger(D, M))
                }
            break
        }
    }
    var L = new Array();
    for (var H = 0; H < C.ON.length; H ++ ) {
        if ( ! wFORMS.helpers.contains(L, C.ON[H])) {
            L.push(C.ON[H])
            }
    }
    var N = new Array();
    for (var H = 0; H < C.OFF.length; H ++ ) {
        if ( ! wFORMS.helpers.contains(N, C.OFF[H])) {
            N.push(C.OFF[H])
            }
    }
    C.ON = L;
    C.OFF = N;
    return C
};
wFORMS.behaviors["switch"].getSwitchNamesFromTrigger = function(B, A) {
    return wFORMS.behaviors["switch"].getSwitchNames(B.className, "trigger", A)
    };
wFORMS.behaviors["switch"].getSwitchNamesFromTarget = function(B, A) {
    return wFORMS.behaviors["switch"].getSwitchNames(B.className, "target", A)
    };
wFORMS.behaviors["switch"].getSwitchNames = function(D, C, H) {
    if ( ! D || D == "") {
        return[]
        }
    var F = D.split(" ");
    var J = new Array();
    if (C == "trigger") {
        var E = true
    } else {
        var E = false
    }
    for (var B = F.length - 1; B >= 0; B -- ) {
        var G = F[B];
        if (E) {
            if (G.indexOf(this.CSS_PREFIX) == 0) {
                var A = G.substring(this.CSS_PREFIX.length)
                }
        } else {
            if (G.indexOf(this.CSS_ONSTATE_PREFIX) == 0) {
                var A = G.substring(this.CSS_ONSTATE_PREFIX.length)
                } else {
                if (G.indexOf(this.CSS_OFFSTATE_PREFIX) == 0) {
                    var A = G.substring(this.CSS_OFFSTATE_PREFIX.length)
                    }
            }
        }
        if (A && ( ! H || wFORMS.helpers.contains(H, A))) {
            J.push(A)
            }
    }
    return J
};
wFORMS.behaviors["switch"].instance.prototype.getTriggersByTarget = function(G) {
    var D = new Array();
    var F = wFORMS.behaviors["switch"].getSwitchNamesFromTarget(G);
    var A = wFORMS.behaviors.repeat;
    for (var C = 0; C < F.length; C ++ ) {
        var H = this.cache[F[C]];
        if (H) {
            for (j = 0; j < H.triggers.length; j ++ ) {
                var E = H.triggers[j];
                for (var B = 0; B < D.length && D[B] != E; B ++ ) {}
                if (B == D.length) {
                    D.push(E)
                    }
            }
        }
    }
    return this.getTriggers(D, F)
    };
wFORMS.behaviors["switch"].isSwitchedOff = function(A) {
    return(A.className.match(new RegExp(wFORMS.behaviors["switch"].CSS_OFFSTATE_PREFIX + "[^ ]*")) ? true: false) && (A.className.match(new RegExp(wFORMS.behaviors["switch"].CSS_ONSTATE_PREFIX + "[^ ]*")) ? false: true)
    };
wFORMS.behaviors["switch"].instance.prototype.setupTargets = function() {
    var A = [];
    for (var C in this.cache) {
        for (var B = 0; B < this.cache[C].triggers.length; B ++ ) {
            var D = this.cache[C].triggers[B];
            if ( ! wFORMS.helpers.contains(A, D)) {
                if (D.tagName != "A" || D.hasClass(this.behavior.CSS_ONSTATE_FLAG)) {
                    A.push(D);
                    this.run(null, D)
                    }
            }
        }
    }
};
wFORMS.behaviors["switch"].instance.prototype.inScope = function(B, D) {
    var C = wFORMS.behaviors.repeat;
    if (C) {
        var A = B;
        while (A &&! A.hasClass(C.CSS_REMOVEABLE) &&! A.hasClass(C.CSS_REPEATABLE)) {
            A = A.parentNode;
            if (A) {
                wFORMS.standardizeElement(A)
                }
        }
        if (A) {
            var E = false;
            while (D) {
                if (D.hasClass(C.CSS_REMOVEABLE) || D.hasClass(C.CSS_REPEATABLE)) {
                    E = true
                }
                if (D == A) {
                    return true
                }
                D = D.parentNode;
                if (D) {
                    wFORMS.standardizeElement(D)
                    }
            }
            return ! E
        }
    }
    return true
};
wFORMS.behaviors["switch"].instance.prototype.run = function(H, D) {
    wFORMS.standardizeElement(D);
    if (D.hasClass(this.behavior.CSS_ONSTATE_FLAG)) {
        D.removeClass(this.behavior.CSS_ONSTATE_FLAG);
        D.addClass(this.behavior.CSS_OFFSTATE_FLAG);
        if (H) {
            H.preventDefault()
            }
    } else {
        if (D.hasClass(this.behavior.CSS_OFFSTATE_FLAG)) {
            D.removeClass(this.behavior.CSS_OFFSTATE_FLAG);
            D.addClass(this.behavior.CSS_ONSTATE_FLAG);
            if (H) {
                H.preventDefault()
                }
        }
    }
    var E = this.getTriggers(new Array(D));
    for (var C = 0; C < E.OFF.length; C ++ ) {
        var A = E.OFF[C];
        for (var B = 0; B < this.cache[A].targets.length; B ++ ) {
            var G = this.cache[A].targets[B];
            if ( ! this.inScope(D, G)) {
                continue
            }
            wFORMS.standardizeElement(G);
            G.addClass(wFORMS.behaviors["switch"].CSS_OFFSTATE_PREFIX + A);
            G.removeClass(wFORMS.behaviors["switch"].CSS_ONSTATE_PREFIX + A);
            var F = this.getTriggersByTarget(G);
            if (F.ON.length == 0) {
                this.behavior.onSwitchOff(G)
                }
        }
    }
    for (var C = 0; C < E.ON.length; C ++ ) {
        var A = E.ON[C];
        for (var B = 0; B < this.cache[A].targets.length; B ++ ) {
            var G = this.cache[A].targets[B];
            if ( ! this.inScope(D, G)) {
                continue
            }
            wFORMS.standardizeElement(G);
            G.removeClass(this.behavior.CSS_OFFSTATE_PREFIX + A);
            G.addClass(this.behavior.CSS_ONSTATE_PREFIX + A);
            this.behavior.onSwitchOn(G)
            }
    }
    if (b = wFORMS.getBehaviorInstance(this.target, "paging")) {
        b.setupManagedControls()
        }
    this.behavior.onSwitch(this.target)
    };
if (typeof(wFORMS) == "undefined") {
    throw new Error("wFORMS core not found. This behavior depends on the wFORMS core.")
    }
wFORMS.behaviors.validation = {
    ERROR_PLACEHOLDER_SUFFIX: "-E",
    rules: {
        oneRequired: {
            selector: ".required-one",
            check: "validateOneRequired"
        },
        isRequired: {
            selector: ".required",
            check: "validateRequired"
        },
        isAlpha: {
            selector: ".validate-alpha",
            check: "validateAlpha"
        },
        isAlphanum: {
            selector: ".validate-alphanum",
            check: "validateAlphanum"
        },
        isDate: {
            selector: ".validate-date",
            check: "validateDate"
        },
        isTime: {
            selector: ".validate-time",
            check: "validateTime"
        },
        isEmail: {
            selector: ".validate-email",
            check: "validateEmail"
        },
        isInteger: {
            selector: ".validate-integer",
            check: "validateInteger"
        },
        isFloat: {
            selector: ".validate-float",
            check: "validateFloat"
        },
        isPhone: {
            selector: ".validate-phone",
            check: "validatePhone"
        },
        isCustom: {
            selector: ".validate-custom",
            check: "validateCustom"
        }
    },
    styling: {
        fieldError: "errFld",
        errorMessage: "errMsg"
    },
    messages: {
        oneRequired: "This section is required.",
        isRequired: "This field is required.",
        isAlpha: "The text must use alphabetic characters only (a-z, A-Z). Numbers are not allowed.",
        isEmail: "This does not appear to be a valid email address.",
        isInteger: "Please enter an integer.",
        isFloat: "Please enter a number (ex. 1.9).",
        isAlphanum: "Please use alpha-numeric characters only [a-z 0-9].",
        isDate: "This does not appear to be a valid date.",
        isPhone: "Please enter a valid phone number.",
        isCustom: "Please enter a valid value.",
        notification: "The form is not complete and has not been submitted yet. There was %% problem(s) with your submission."
    },
    instance: function(B) {
        this.behavior = wFORMS.behaviors.validation;
        this.target = B;
        var A = this;
        if ( ! B.__wFormsValidationHandled) {
            if ( ! B.addEventListener) {
                wFORMS.standardizeElement(B)
                }
            B.addEventListener("submit", function(C) {
                return A.run(C, this)
                }, false);
            B.__wFormsValidationHandled = true
        }
    },
    onPass: function(A, B) {},
    onFail: function(A, B) {},
    dateRegex: (function() {
        var D = "((January)|(Feburary)|(March)|(April)|(May)|(June)|(July)|(August)|(September)|(October)|(November)|(December)|(Jan)|(Feb)|(Mar)|(Apr)|(May)|(Jun)|(Jul)|(Aug)|(Sep)|(Oct)|(Nov)|(Dec))";
        var J = "\\d{1,2}";
        var F = "(\\d{1,4}|\\d{1,2})";
        var E = "(" + J + "|" + D + ")";
        var G = "\\d{1,2}((th)|(rd)|(nd)|(st))?";
        var A = "\\s*[-/\\\\|\\,\\.]?\\s*";
        var C = "((" + E + A + G + ")|(" + G + A + E + ")|(" + E + "))";
        var H = "((" + F + A + C + ")|(" + C + A + F + ")|" + C + ")";
        var B = "(\\d{1,2}\\s*[:-]?\\s*\\d{1,2}(\\s*[:-]?\\s*\\d{1,2})?)";
        return[new RegExp("^" + H + "\\s+" + B + "$", "i"), new RegExp("^" + B + "\\s+" + H + "$", "i"), new RegExp("^" + H + "$", "i"), new RegExp("^" + B + "$", "i")]
        })
    ()
    };
wFORMS.behaviors.validation.applyTo = function(D) {
    if ( ! D ||! D.tagName) {
        throw new Error("Can't apply behavior to " + D)
        }
    if (D.tagName != "FORM") {
        if (D.form) {
            D = D.form
        } else {
            var E = D;
            for (D = D.parentNode; D && D.tagName != "FORM"; D = D.parentNode) {
                continue
            }
            if ( ! D || D.tagName != "FORM") {
                D = E.getElementsByTagName("form")
                }
        }
    }
    if ( ! D.tagName && D.length > 0) {
        var A = new Array();
        for (var B = 0; B < D.length; B ++ ) {
            var C = new wFORMS.behaviors.validation.instance(D[B]);
            A.push(C);
            C.onApply()
            }
    } else {
        var A = new wFORMS.behaviors.validation.instance(D);
        A.onApply()
        }
    return A
};
wFORMS.behaviors.validation.instance.prototype.onApply = function() {};
wFORMS.behaviors.validation.instance.prototype.run = function(E, B) {
    if (E && E.pagingStopPropagation) {
        return false
    }
    var F = function(H) {
        if (wFORMS.behaviors.paging &&! wFORMS.behaviors.paging.isElementVisible(H)) {
            return
        }
        if (A.isSwitchedOff(H)) {
            return
        }
        var J = wFORMS.helpers.getFieldValue(H);
        if (D.check.call) {
            var L = D.check.call(A, H, J)
            } else {
            var L = A[D.check].call(A, H, J)
            }
        if ( ! L) {
            if ( ! H.id) {
                H.id = wFORMS.helpers.randomId()
                }
            A.elementsInError[H.id] = {
                id: H.id,
                rule: C
            };
            A.removeErrorMessage(H);
            if (D.fail) {
                D.fail.call(A, H, C)
                } else {
                A.fail.call(A, H, C)
                }
            G ++ 
        } else {
            if ( ! A.elementsInError[H.id]) {
                A.removeErrorMessage(H)
                }
            if (D.pass) {
                D.pass.call(A, H)
                } else {
                A.pass.call(A, H)
                }
        }
    };
    var G = 0;
    this.elementsInError = {};
    for (var C in this.behavior.rules) {
        var D = this.behavior.rules[C];
        var A = this;
        if ( ! B.matchesSelector) {
            wFORMS.standardizeElement(B)
            }
        if ( ! B.matchesSelector) {
            B = base2.DOM.bind(B)
            }
        if ( ! B.matchesSelector && B.msMatchesSelector) {
            B.matchesSelector = B.msMatchesSelector
        }
        if ( ! B.matchesSelector && B.mozMatchesSelector) {
            B.matchesSelector = B.mozMatchesSelector
        }
        if ( ! B.matchesSelector && B.webkitMatchesSelector) {
            B.matchesSelector = B.webkitMatchesSelector
        }
        if ( ! B.matchesSelector) {
            B.matchesSelector = base2.DOM.Element.matchesSelector
        }
        if (B.matchesSelector(D.selector)) {
            F(B)
            }
        B.querySelectorAll(D.selector).forEach(F)
        }
    if (G > 0) {
        if (E) {
            E.preventDefault ? E.preventDefault(): E.returnValue = false
        }
        if (this.behavior.onFail) {
            this.behavior.onFail(this, E)
            }
        return false
    }
    if (this.behavior.onPass) {
        this.behavior.onPass(this, E)
        }
	//For ClearSaeling
    populate_variable();
	
    return true
};
wFORMS.behaviors.validation.instance.prototype.fail = function(A, B) {
    var C = document.getElementById(A.id + "-D");
    if (C) {
        if ( ! C.hasClass) {
            wFORMS.standardizeElement(C)
            }
        C.addClass(this.behavior.styling.fieldError)
        } else {
        A.addClass(this.behavior.styling.fieldError)
        }
    this.addErrorMessage(A, this.behavior.messages[B])
    },
wFORMS.behaviors.validation.instance.prototype.pass = function(A) {};
wFORMS.behaviors.validation.instance.prototype.addErrorMessage = function(A, B) {
    if ( ! A.id) {
        A.id = wFORMS.helpers.randomId()
        }
    var C = document.createElement("span");
    C.appendChild(document.createTextNode(B));
    var D = document.getElementById(A.id + this.behavior.ERROR_PLACEHOLDER_SUFFIX);
    if ( ! D) {
        D = document.createElement("div");
        D.setAttribute("id", A.id + this.behavior.ERROR_PLACEHOLDER_SUFFIX);
        if (A.tagName == "TR") {
            if (A.getElementsByTagName("TH").length > 0) {
                D = (A.getElementsByTagName("TH")[0]).appendChild(D)
                } else {
                D = (A.getElementsByTagName("TD")[0]).appendChild(D)
                }
        } else {
            if (A.hasClass("wfSection") || A.hasClass("inlineSection")) {
                D = A.appendChild(D)
                } else {
                var E = document.getElementById(A.id + "-D");
                if (E) {
                    D = E.appendChild(D)
                    } else {
                    D = A.parentNode.insertBefore(D, A.nextSibling)
                    }
            }
        }
    }
    D.appendChild(C);
    wFORMS.standardizeElement(D);
    D.addClass(this.behavior.styling.errorMessage)
    };
wFORMS.behaviors.validation.instance.prototype.removeErrorMessage = function(B) {
    var C = document.getElementById(B.id + "-D");
    if ( ! B.hasClass) {
        wFORMS.standardizeElement(B)
        }
    if (C &&! C.hasClass) {
        wFORMS.standardizeElement(C)
        }
    if (B.hasClass(this.behavior.styling.fieldError)) {
        B.removeClass(this.behavior.styling.fieldError)
        }
    if (C && C.hasClass(this.behavior.styling.fieldError)) {
        C.removeClass(this.behavior.styling.fieldError)
        }
    var A = document.getElementById(B.id + this.behavior.ERROR_PLACEHOLDER_SUFFIX);
    if (A) {
        A.parentNode.removeChild(A)
        }
};
wFORMS.behaviors.validation.instance.prototype.isSwitchedOff = function(B) {
    var C = wFORMS.getBehaviorInstance(this.target, "switch");
    if (C) {
        var A = B;
        while (A && A.tagName != "BODY") {
            if (A.className && A.className.indexOf(C.behavior.CSS_OFFSTATE_PREFIX) !=- 1 && A.className.indexOf(C.behavior.CSS_ONSTATE_PREFIX) ==- 1) {
                return true
            }
            A = A.parentNode
        }
    }
    return false
};
wFORMS.behaviors.validation.isErrorPlaceholderId = function(A) {
    return A.match(new RegExp(wFORMS.behaviors.validation.ERROR_PLACEHOLDER_SUFFIX + "$")) != null
};
wFORMS.behaviors.validation.instance.prototype.isEmpty = function(A) {
    var B = /^\s+$/;
    return((A == null) || (A.length == 0) || B.test(A))
    };
wFORMS.behaviors.validation.instance.prototype.validateRequired = function(A, D) {
    switch(A.tagName) {
        case "INPUT": var B = A.getAttribute("type");
        if ( ! B) {
            B = "text"
        }
        switch(B.toLowerCase()) {
            case "checkbox": case "radio": return A.checked;
            break;
            case "file": var C = document.getElementById("tfa_uploadDelete_" + A.id);
            if (this.isEmpty(D)) {
                return(C &&! C.checked)
                }
            return true;
            break;
            default: return ! this.isEmpty(D)
            }
        break;
        case "SELECT": return ! this.isEmpty(D);
        break;
        case "TEXTAREA": return ! this.isEmpty(D);
        break;
        default: return this.validateOneRequired(A);
        break
    }
    return false
};
wFORMS.behaviors.validation.instance.prototype.validateOneRequired = function(B) {
    if (B.nodeType != 1) {
        return false
    }
    if (this.isSwitchedOff(B)) {
        return false
    }
    switch(B.tagName) {
        case "INPUT": var C = B.getAttribute("type");
        if ( ! C) {
            C = "text"
        }
        switch(C.toLowerCase()) {
            case "checkbox": case "radio": return B.checked;
            break;
            case "file": var D = document.getElementById("tfa_uploadDelete_" + B.id);
            if (this.isEmpty(wFORMS.helpers.getFieldValue(B))) {
                return(D &&! D.checked)
                }
            return true;
            break;
            default: return ! this.isEmpty(wFORMS.helpers.getFieldValue(B))
            }
        break;
        case "SELECT": return ! this.isEmpty(wFORMS.helpers.getFieldValue(B));
        break;
        case "TEXTAREA": return ! this.isEmpty(wFORMS.helpers.getFieldValue(B));
        break;
        default: for (var A = 0; A < B.childNodes.length; A ++ ) {
            if (this.validateOneRequired(B.childNodes[A])) {
                return true
            }
        }
        break
    }
    return false
};
wFORMS.behaviors.validation.instance.prototype.validateAlpha = function(A, C) {
    var B = /^[a-zA-Z\s]+$/;
    return this.isEmpty(C) || B.test(C)
    };
wFORMS.behaviors.validation.instance.prototype.validateAlphanum = function(A, C) {
    var B = /^[\w\s]+$/;
    return this.isEmpty(C) || B.test(C)
    };
wFORMS.behaviors.validation.instance.prototype.validateDate = function(B, D) {
    if (this.isEmpty(D)) {
        return true
    }
    var C = wFORMS.behaviors.validation.dateRegex;
    for (var A = 0; A < C.length - 1; A ++ ) {
        if (C[A].test(D)) {
            return true
        }
    }
    return false
};
wFORMS.behaviors.validation.instance.prototype.validateTime = function(A, B) {
    return true
};
wFORMS.behaviors.validation.instance.prototype.validateEmail = function(A, B) {
    var C = /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,}$/;
    return this.isEmpty(B) || C.test(B)
    };
wFORMS.behaviors.validation.instance.prototype.validateInteger = function(A, C) {
    var B = /^[\-+]?\d+$/;
    return this.isEmpty(C) || B.test(C)
    };
wFORMS.behaviors.validation.instance.prototype.validateFloat = function(A, C) {
    var B = /^((([1-9]\d*|0)?\.\d+)|([1-9]\d*))$/;
    return this.isEmpty(C) || B.test(C)
    };
wFORMS.behaviors.validation.instance.prototype.validatePhone = function(B, D) {
    if (this.isEmpty(D)) {
        return true
    }
    var A = [/^[\d\-\. \+\(\)]+$/, /^[\d\-\. \+\(\)]+ # {0,1}\d+ *$/, /^[\d\-\. \+\(\)]+ ext\.{0,1} \d+ *$/];
    for (var C in A) {
        if (A[C].test(D)) {
            return true
        }
    }
    return false
};
wFORMS.behaviors.validation.instance.prototype.validateCustom = function(A, D) {
    var C = new RegExp("/(.*)/([gi]*)");
    var B = A.className.match(C);
    if (this.isEmpty(D)) {
        return true
    }
    if (B && B[0]) {
        var E = new RegExp(B[1], B[2]);
        if ( ! D.match(E)) {
            return false
        }
    }
    return true
};
if (typeof(wFORMS) == "undefined") {
    throw new Error("wFORMS core not found. This behavior depends on the wFORMS core.")
    }
wFORMS.behaviors.calculation = {
    VARIABLE_SELECTOR_PREFIX: "calc-",
    CHOICE_VALUE_SELECTOR_PREFIX: "calcval-",
    CALCULATION_SELECTOR: '*[class*="formula="]',
    CALCULATION_ERROR_MESSAGE: "There was an error computing this field.",
    instance: function(A) {
        this.behavior = wFORMS.behaviors.calculation;
        this.target = A;
        this.calculations = []
        }
};
wFORMS.behaviors.calculation.applyTo = function(C) {
    while (C && C.tagName != "FORM") {
        C = C.parentNode
    }
    var B = wFORMS.getBehaviorInstance(C, "calculation");
    if ( ! B) {
        B = new wFORMS.behaviors.calculation.instance(C)
        } else {
        B.calculations = []
        }
    if (wFORMS.behaviors.repeat &&! B._repeatRemoveHandler) {
        var A = wFORMS.behaviors.repeat.onRemove;
        B._repeatRemoveHandler = function() {
            wFORMS.behaviors.calculation.applyTo(C);
            if (A) {
                A.apply(this, arguments)
                }
        };
        wFORMS.behaviors.repeat.onRemove = B._repeatRemoveHandler
    }
    C.querySelectorAll(wFORMS.behaviors.calculation.CALCULATION_SELECTOR).forEach(function(F) {
        var H = F.className.substr(F.className.indexOf("formula=") + 8).split(" ")[0];
        var G = H.split(/[^a-zA-Z]+/g);
        B.varFields = [];
        for (var E = 0; E < G.length; E ++ ) {
            if (G[E] != "") {
                base2.DOM.Document.querySelectorAll(C, '*[class*="' + wFORMS.behaviors.calculation.VARIABLE_SELECTOR_PREFIX + G[E] + '"]').forEach(function(J) {
                    if ( ! J.addEventListener) {
                        base2.DOM.bind(J)
                        }
                    var M = ((" " + J.className + " ").indexOf(" " + wFORMS.behaviors.calculation.VARIABLE_SELECTOR_PREFIX + G[E] + " ") !=- 1);
                    if ( ! M) {
                        return
                    }
                    if ( ! wFORMS.behaviors.calculation.isHandled(J)) {
                        var L = J.tagName.toLowerCase();
                        if (L == "input" || L == "textarea") {
                            var N = J.type.toLowerCase();
                            if (L == "input" && (N == "radio" || N == "checkbox")) {
                                J.addEventListener("click", function(O) {
                                    return B.run(O, this)
                                    }, false);
                                wFORMS.behaviors.calculation.setHandledFlag(J)
                                } else {
                                J.addEventListener("blur", function(O) {
                                    return B.run(O, this)
                                    }, false);
                                wFORMS.behaviors.calculation.setHandledFlag(J)
                                }
                        } else {
                            if (L == "select") {
                                J.addEventListener("change", function(O) {
                                    return B.run(O, this)
                                    }, false);
                                wFORMS.behaviors.calculation.setHandledFlag(J)
                                } else {
                                return
                            }
                        }
                    }
                    B.varFields.push( {
                        name: G[E],
                        field: J
                    })
                    })
                }
        }
        var D = {
            field: F,
            formula: H,
            variables: B.varFields
        };
        B.calculations.push(D);
        B.compute(D)
        });
    B.onApply();
    return B
};
wFORMS.behaviors.calculation.instance.prototype.onApply = function() {};
wFORMS.behaviors.calculation.instance.prototype.run = function(E, D) {
    for (var C = 0; C < this.calculations.length; C ++ ) {
        var B = this.calculations[C];
        for (var A = 0; A < B.variables.length; A ++ ) {
            if (D == B.variables[A].field) {
                this.compute(B)
                }
        }
    }
};
wFORMS.behaviors.calculation.instance.prototype.refresh = function(D, C) {
    for (var B = 0; B < this.calculations.length; B ++ ) {
        var A = this.calculations[B];
        if (C == A.field) {
            this.compute(A)
            }
    }
};
wFORMS.behaviors.calculation.instance.prototype.compute = function(calculation) {
    var f = this.target;
    var formula = calculation.formula;
    var _processedVariables = new Array();
    for (var i = 0; i < calculation.variables.length; i ++ ) {
        var v = calculation.variables[i];
        var varval = 0;
        var _self = this;
        if (wFORMS.helpers.contains(_processedVariables, v.name)) {
            continue
        } else {
            _processedVariables.push(v.name)
            }
        base2.DOM.Document.querySelectorAll(f, '*[class*="' + _self.behavior.VARIABLE_SELECTOR_PREFIX + v.name + '"]').forEach(function(variable) {
            var exactMatch = ((" " + variable.className + " ").indexOf(" " + wFORMS.behaviors.calculation.VARIABLE_SELECTOR_PREFIX + v.name + " ") !=- 1);
            if ( ! exactMatch) {
                return
            }
            if ( ! _self.inScope(calculation.field, variable)) {
                return
            }
            if (_self.hasValueInClassName(variable)) {
                var value = _self.getValueFromClassName(variable)
                } else {
                var value = wFORMS.helpers.getFieldValue(variable)
                }
            if ( ! value) {
                value = 0
            }
            if (value.constructor == Array) {
                for (var j = 0; j < value.length; j ++ ) {
                    if (String(value[j]).search(/^[\d\.,]*$/) !=- 1) {
                        varval += parseFloat(value[j])
                        } else { ( ! varval) ? (varval = value[j]): (varval = String(varval).concat(value[j]))
                        }
                }
            } else {
                if (String(value).search(/^[\d\.,]*$/) !=- 1) {
                    varval += parseFloat(value)
                    } else { ( ! varval) ? (varval = value): (varval = String(varval).concat(value))
                    }
            }
        });
        if (String(varval).search(/^[\d\.,]*$/) !=- 1) {
            formula = "var " + v.name + " = " + varval + "; " + formula
        } else {
            formula = "var " + v.name + ' = "' + varval.replace(/\"/g, '\\"') + '"; ' + formula
        }
    }
    try {
        var calc = function() {
            return eval(formula)
            };
        var result = calc();
        if (result == "Infinity" || result == "NaN" || String(result).match("NaN")) {
            result = "error"
        }
    }
    catch(x) {
        result = "error"
    }
    var validationBehavior = wFORMS.getBehaviorInstance(this.target, "validation");
    if (validationBehavior) {
        if ( ! wFORMS.behaviors.validation.messages["calculation"]) {
            wFORMS.behaviors.validation.messages["calculation"] = this.behavior.CALCULATION_ERROR_MESSAGE
        }
        validationBehavior.removeErrorMessage(calculation.field);
        if (result == "error") {
            validationBehavior.fail(calculation.field, "calculation")
            }
    }
    calculation.field.value = result;
    if (calculation.field.className && (calculation.field.className.indexOf(this.behavior.VARIABLE_SELECTOR_PREFIX) !=- 1)) {
        this.run(null, calculation.field)
        }
};
wFORMS.behaviors.calculation.instance.prototype.hasValueInClassName = function(B) {
    switch(B.tagName) {
        case "SELECT": for (var A = 0; A < B.options.length; A ++ ) {
            if (B.options[A].className && B.options[A].className.indexOf(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX) !=- 1) {
                return true
            }
        }
        return false;
        break;
        default: if ( ! B.className || (" " + B.className).indexOf(" " + this.behavior.CHOICE_VALUE_SELECTOR_PREFIX) ==- 1) {
            return false
        }
        break
    }
    return true
};
wFORMS.behaviors.calculation.instance.prototype.getValueFromClassName = function(C) {
    switch(C.tagName) {
        case "INPUT": if ( ! C.className || C.className.indexOf(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX) ==- 1) {
            return null
        }
        var D = C.className.split(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX)[1].split(" ")[0];
        if (C.type == "checkbox") {
            return C.checked ? D: null
        }
        if (C.type == "radio") {
            return C.checked ? D: null
        }
        return D;
        break;
        case "SELECT": if (C.selectedIndex ==- 1) {
            return null
        }
        if (C.multiple) {
            var A = [];
            for (var B = 0; B < C.options.length; B ++ ) {
                if (C.options[B].selected) {
                    if (C.options[B].className && C.options[B].className.indexOf(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX) !=- 1) {
                        var D = C.options[B].className.split(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX)[1].split(" ")[0];
                        A.push(D)
                        }
                }
            }
            if (A.length == 0) {
                return null
            }
            return A
        }
        if (C.options[C.selectedIndex].className && C.options[C.selectedIndex].className.indexOf(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX) !=- 1) {
            var D = C.options[C.selectedIndex].className.split(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX)[1].split(" ")[0];
            return D
        }
        break;
        case "TEXTAREA": if ( ! C.className || C.className.indexOf(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX) ==- 1) {
            return null
        }
        var D = C.className.split(this.behavior.CHOICE_VALUE_SELECTOR_PREFIX)[1].split(" ")[0];
        return D;
        break;
        default: return null;
        break
    }
    return null
};
wFORMS.behaviors["calculation"].isHandled = function(A) {
    return(A._wforms_calc_handled === true)
    };
wFORMS.behaviors["calculation"].setHandledFlag = function(A) {
    A._wforms_calc_handled = true
};
wFORMS.behaviors["calculation"].removeHandledFlag = function(A) {
    try {
        delete A._wforms_calc_handled
    }
    catch(B) {
        A._wforms_calc_handled = undefined
    }
};
wFORMS.behaviors.calculation.instance.prototype.inScope = function(E, A) {
    var B = wFORMS.behaviors.repeat;
    if (B) {
        var D = E;
        if ( ! D.hasClass) {
            wFORMS.standardizeElement(D)
            }
        while (D &&! D.hasClass(B.CSS_REMOVEABLE) &&! D.hasClass(B.CSS_REPEATABLE)) {
            D = D.parentNode;
            if (D) {
                wFORMS.standardizeElement(D)
                }
        }
        if (D) {
            var C = false;
            while (A) {
                if ( ! A.hasClass) {
                    wFORMS.standardizeElement(A)
                    }
                if (A.hasClass(B.CSS_REMOVEABLE) || A.hasClass(B.CSS_REPEATABLE)) {
                    C = true
                }
                if (A == D) {
                    return true
                }
                A = A.parentNode;
                if (A) {
                    wFORMS.standardizeElement(A)
                    }
            }
            return ! C
        }
    }
    return true
}