( function() {
	ClearChannel = {
		Browser: {
			IE:!!(window.attachEvent && navigator.userAgent.indexOf('Opera') === -1),
			Opera:navigator.userAgent.indexOf('Opera') > -1,
			WebKit:navigator.userAgent.indexOf('AppleWebKit/') > -1,
			Gecko:navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') === -1,
			MobileSafari:!!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
	  	},
		ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
		JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/g,
		emptyFunction : function() {
			return;
		},
		copy : function(source, destination) {
			for ( var property in source) {
				if (!destination.hasOwnProperty(property)) {
					destination[property] = source[property];
				}
			}
		},
		castToString: function(value) {
		    return value == null ? '' : String(value);
		},
		Array : function(iterable) {
			if (!iterable)
				return [];
			if (!(typeof iterable === 'function'
					&& typeof iterable.length === 'number' && typeof iterable.item === 'function')
					&& iterable.toArray)
				return iterable.toArray();
			var length = iterable.length || 0, results = new Array(length);
			while (length--)
				results[length] = iterable[length];
			return results;
		},
		these : function() {
			var ret;
			for ( var i = 0, length = arguments.length; i < length; i++) {
				var current = arguments[i];
				try {
					ret = current();
					break;
				} catch (e) {
				}
			}
			return ret;
		},
		getWindowX:function(){
			if(window.screenLeft){
				return window.screenLeft;
			}else if(window.screenX){
				return window.screenX;
			}else{
				return 0;
			}
		},
		getWindowY:function(){
			if(window.screenLeft){
				return window.screenTop;
			}else if(window.screenY){
				return window.screenY;
			}else{
				return 0;
			}
		},
		getViewportWidth : function(){
			if(window.innerWidth){
				return window.innerWidth;
			}else if(ClearChannel.Browser.IE && document.documentElement && document.documentElement.clientWidth != 0){
				return document.documentElement.clientWidth;
			}else if(ClearChannel.Browser.IE && document.getElementsByTagName('body')[0].clientWidth != 0){
				return document.getElementsByTagName('body')[0].clientWidth;
			}else{
				return 600;
			}
		},
		getViewportHeight:function(){
			if(window.innerWidth){
				return window.innerHeight;
			}else if(ClearChannel.Browser.IE && document.documentElement && document.documentElement.clientWidth != 0){
				return document.documentElement.clientHeight;
			}if(ClearChannel.Browser.IE && document.getElementsByTagName('body')[0].clientWidth != 0){
				return document.getElementsByTagName('body')[0].clientHeight;
			}else{
				return 400;
			}
		},
		getHorizontalScroll:function(){
			if(window.innerWidth){
				return window.pageXOffset;
			}else if(ClearChannel.Browser.IE && document.documentElement){
				return document.documentElement.scrollLeft;
			}else if(ClearChannel.Browser.IE){
				return document.body.scrollLeft;
			}else{
				return 200;
			}
		},
		getVerticalScroll:function(){
			if(window.innerWidth){
				return window.pageYOffset;
			}else if(ClearChannel.Browser.IE && document.documentElement){
				return document.documentElement.scrollTop;
			}else if(ClearChannel.Browser.IE){
				return document.body.scrollTop;
			}else{
				return 100;
			}
		}
	};
	var arrayCopyObject = {
		ClearChannelArrayCopy : function() {
			var returnArray = [];
			for ( var i = 0, length = this.length; i < length; i++) {
				if (this[i] != undefined) {
					if (typeof (this[i]) != 'string'
							&& typeof (this[i]) != 'number') {
						if (this[i] instanceof Array) {
							var arr = this[i].ClearChannelArrayCopy();
							returnArray.push(arr);
						} else {
							var obj = {};
							ClearChannel.copy(this[i], obj);
							returnArray.push(obj);
						}
					} else {
						returnArray.push(this[i]);
					}
				}
			}
			return returnArray;
		}
	};
	var anchorObject = {
		ClearChannelAnchor : function() {
			var __func = this;
			var args = ClearChannel.Array(arguments);
			var object = args.shift();
			return function() {
				__func.apply(object, args);
			};
		},
		ClearChannelAnchorEventListener : function() {
			var __func = this;
			var args = ClearChannel.Array(arguments);
			var object = args.shift();
			return function() {
				__func.apply(object, [ event || window.event ].concat(args));
			};
		}
	};
	ClearChannel.copy(arrayCopyObject, Array.prototype);
	ClearChannel.copy(anchorObject, Function.prototype);    
    ClearChannel.Listener = function(event_type, call_back, objectContext){
    	var _object = (function(){if(typeof objectContext != 'undefined' && objectContext != null){return objectContext;}else{return window;}})();
    	var _eventType = event_type || 'event';
    	var _callBack=(function(){if(typeof call_back != 'undefined' && call_back instanceof Function){return call_back;}else{return ClearChannel.emptyFunction;}})();
    	this.getEventType = function(){return _eventType;};
    	this.getCallBack = function(){return _callBack;};
    	this.getObject = function(){return _object;};
    };
    ClearChannel.Listener.prototype = (function(){return new Object();})();
    ClearChannel.AjaxListener = function(event_type, call_back, objectContext){
    	var t = '';
    	//make sure that the event type matches one of the ajax event types
    	switch(event_type.toLowerCase()){
    	case ClearChannel.AjaxEvent.prototype.SUCCESS.toLowerCase():
    			t=ClearChannel.AjaxEvent.prototype.SUCCESS;
    	break;
    	case 'on200'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.OK.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.OK;
    	break;
    	case 'onCreate'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.CREATED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.CREATED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.ACCEPTED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.ACCEPTED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.PARTIAL_INFORMATION.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.PARTIAL_INFORMATION;
    	break;
    	case ClearChannel.AjaxEvent.prototype.NO_RESPONSE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NO_RESPONSE;
    	break;
    	case ClearChannel.AjaxEvent.prototype.FAILURE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.FAILURE;
    	break;
    	case ClearChannel.AjaxEvent.prototype.BAD_REQUEST.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.BAD_REQUEST;
    	break;
    	case ClearChannel.AjaxEvent.prototype.UNAUTHORIZED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.UNAUTHORIZED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.PAYMENT_REQUIRED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.PAYMENT_REQUIRED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.FORBIDDEN.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.FORBIDDEN;
    	break;
    	case 'on404'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.NOT_FOUND.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NOT_FOUND;
    	break;
    	case ClearChannel.AjaxEvent.prototype.INTERNAL_ERROR.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.INTERNAL_ERROR;
    	break;
    	case ClearChannel.AjaxEvent.prototype.NOT_IMPLEMENTED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NOT_IMPLEMENTED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.SERVICE_TEMPORARILY_OVERLOADED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.SERVICE_TEMPORARILY_OVERLOADED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.GATEWAY_TIMEOUT.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.GATEWAY_TIMEOUT;
    	break;
    	case ClearChannel.AjaxEvent.prototype.REDIRECTION.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.REDIRECTION;
    	break;
    	case ClearChannel.AjaxEvent.prototype.MOVED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.MOVED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.FOUND.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.FOUND;
    	break;
    	case ClearChannel.AjaxEvent.prototype.METHOD.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.METHOD;
    	break;
    	case ClearChannel.AjaxEvent.prototype.METHOD.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.METHOD;
    	break;
    	case ClearChannel.AjaxEvent.prototype.NOT_MODIFIED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NOT_MODIFIED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.UNINITIALIZED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.UNINITIALIZED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.LOADING.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.LOADING;
    	break;
    	case ClearChannel.AjaxEvent.prototype.LOADED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.LOADED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.INTERACTIVE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.INTERACTIVE;
    	break;
    	case 'onComplete'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.COMPLETE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.COMPLETE;
    	break;
    	case 'onException'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.EXCEPTION.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.EXCEPTION;
    	break;
    	case 'oncreate':
    	case ClearChannel.AjaxEvent.prototype.ONCREATE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.ONCREATE;
    	break;
    	default:
    		//it doesn't match, so use the catchall AJAXEVENT type that never gets fired
    		t = 'AJAXEVENT';    	
    	}
    	ClearChannel.Listener.call(this, t, call_back, objectContext);
    	this.name = 'ClearChannel.AjaxListener';
    };
    ClearChannel.AjaxListener.prototype = (function(){return new ClearChannel.Listener();})();
    ClearChannel.EventDispatcher = function(){
    	this.name ='ClearChannel.EventDispatcher'; 
    	var _listeners = ClearChannel.Array();
    	//only call this inside of children, it is a workaround to make sure that _listeners is defined on child classes
    	this.getListeners = function(){
    		return _listeners;
    	};
    	this.hasEventListener=function(event_type, call_back, object){
    		for(var i =0, length = _listeners.length;i<length;i++){
    			if(_listeners[i].getEventType() == event_type && _listeners[i].getCallBack() == call_back && _listeners[i].getObject() == object){
    				return true;
    				break;
    			}
    		}
    		return false;
    	};
    	this.addEventListener = function(event_type, call_back, object){
    		if(!this.hasEventListener(event_type, call_back, object)){
    			_listeners.push(new ClearChannel.Listener(event_type, call_back, object));
    		}
    	};
    	this.removeEventListener = function(event_type, call_back, object){
    		for(var i = 0, length = _listeners.length; i<length;i++){
    			if(_listeners[i].getEventType() ==event_type && _listeners[i].getCallBack() == call_back && _listeners[i].getObject() == object){
    				delete _listeners[i];
    			}
    		}
    		var newListeners = _listeners.ClearChannelArrayCopy();
    		_listeners = newListeners.slice();
    		delete newListeners;
    	};
    	this.dispatchEvent=function(event){
    		for(var i = 0, length = _listeners.length;i<length;i++){
    			try{
    				if(event.getCanceled()==true){
    					event.reset();
    					return null;
    				}else{
    					if(_listeners[i].getEventType() == event.getEventType()){
    						
    						_listeners[i].getCallBack().apply(_listeners[i].getObject(), ClearChannel.Array([event]));
    					}
    				}
    			}catch(e){
    			}
    		}	
    	};
    	this.unloadListeners=function(event){
    		try{
    		for(var i = 0, length = _listeners.length; i<length;i++){
    			_listeners[i] = null;
    		}
    		delete _listeners;
    		}catch(e){}
    		
    	};
    	try{
    		if (window.attachEvent) {
    		    window.attachEvent("onunload", this.unloadListeners.ClearChannelAnchor(this));
    		  }else{
    			  window.addEventListener('unload', this.unloadListeners.ClearChannelAnchor(this), false);
    		  }
    	}catch(e){
    		
    	}
    };
    ClearChannel.EventDispatcher.prototype = (function(){return new Object();})();
    ClearChannel.Error = function(message, fileName, lineNumber){
    	this.message=message;
    	this.fileName=fileName;
    	this.lineNumber=lineNumber;
    };
    ClearChannel.Error.prototype = (function(){return new Error();})();
    ClearChannel.AjaxError = function(message, fileName, lineNumber, requestObject, responseObject){
    	ClearChannel.Error.call(message, fileName, lineNumber);
    	this._requestObject = (function(){
    		if(requestObject instanceof ClearChannel.Ajax){
    			return requestObject;
    		}else{
    			return new ClearChannel.Ajax();
    		}
    	})();
    	this._responseObject =(function(){
    		
    		if(responseObject instanceof ClearChannel.AjaxResponse){
    			return responseObject;
    		}else{
    			return new ClearChannel.AjaxResponse();
    		}
    	})();
    };
    ClearChannel.AjaxError.prototype = (function(){return new ClearChannel.Error();})();
    ClearChannel.Event = function(type, bubbles, canceleable){
    	var _eventType = type || 'cevent';
    	var _cancelable = canceleable || false;
    	var _bubbles = bubbles || false;
    	var _canceled = false;
    	this.getEventType = function(){
    		return _eventType;    		
    	};
    	this.getCancelable=function(){
    		return _cancelable;
    	};
    	this.getBubbles =function(){
    		return _bubbles;
    	};
    	this.getCanceled = function(){
    		return _canceled;
    	};
    	this.stopPropagation = function(){
    		if(_cancelable){
    			_canceled = true;
    		}
    	};
    	this.reset = function(){
    		_canceled = false;
    	};
    };
    ClearChannel.Event.prototype = (function(){return new Object();})();
    ClearChannel.MessageEvent = function(type, bubbles, canceleable, message){
    	ClearChannel.Event.call(this, type, bubbles, canceleable);
    	var _message = message || "";
    	this.getMessage=function(){
    		return _message;    		
    	};
    };
    ClearChannel.MessageEvent.prototype = (function(){return new ClearChannel.Event();})();
    ClearChannel.AjaxEvent = function(type, responseObj){
    	//Make sure the event type matches one of the ajax event types, or a catchall if it doesn't
    	var t = '';
    	switch(type.toLowerCase()){
    	case ClearChannel.AjaxEvent.prototype.SUCCESS.toLowerCase():
    			t=ClearChannel.AjaxEvent.prototype.SUCCESS;
    	break;
    	case 'on200'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.OK.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.OK;
    	break;
    	case ClearChannel.AjaxEvent.prototype.CREATED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.CREATED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.ACCEPTED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.ACCEPTED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.PARTIAL_INFORMATION.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.PARTIAL_INFORMATION;
    	break;
    	case ClearChannel.AjaxEvent.prototype.NO_RESPONSE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NO_RESPONSE;
    	break;
    	case ClearChannel.AjaxEvent.prototype.FAILURE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.FAILURE;
    	break;
    	case ClearChannel.AjaxEvent.prototype.BAD_REQUEST.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.BAD_REQUEST;
    	break;
    	case ClearChannel.AjaxEvent.prototype.UNAUTHORIZED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.UNAUTHORIZED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.PAYMENT_REQUIRED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.PAYMENT_REQUIRED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.FORBIDDEN.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.FORBIDDEN;
    	break;
    	case 'on404'.toLowerCase():
    	case ClearChannel.AjaxEvent.prototype.NOT_FOUND.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NOT_FOUND;
    	break;
    	case ClearChannel.AjaxEvent.prototype.INTERNAL_ERROR.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.INTERNAL_ERROR;
    	break;
    	case ClearChannel.AjaxEvent.prototype.NOT_IMPLEMENTED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NOT_IMPLEMENTED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.SERVICE_TEMPORARILY_OVERLOADED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.SERVICE_TEMPORARILY_OVERLOADED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.GATEWAY_TIMEOUT.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.GATEWAY_TIMEOUT;
    	break;
    	case ClearChannel.AjaxEvent.prototype.REDIRECTION.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.REDIRECTION;
    	break;
    	case ClearChannel.AjaxEvent.prototype.MOVED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.MOVED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.FOUND.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.FOUND;
    	break;
    	case ClearChannel.AjaxEvent.prototype.METHOD.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.METHOD;
    	break;
    	case ClearChannel.AjaxEvent.prototype.METHOD.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.METHOD;
    	break;
    	case ClearChannel.AjaxEvent.prototype.NOT_MODIFIED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.NOT_MODIFIED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.UNINITIALIZED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.UNINITIALIZED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.LOADING.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.LOADING;
    	break;
    	case ClearChannel.AjaxEvent.prototype.LOADED.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.LOADED;
    	break;
    	case ClearChannel.AjaxEvent.prototype.INTERACTIVE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.INTERACTIVE;
    	break;
    	case 'oncomplete':
    	case ClearChannel.AjaxEvent.prototype.COMPLETE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.COMPLETE;
    	break;
    	case 'onexception':
    	case ClearChannel.AjaxEvent.prototype.EXCEPTION.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.EXCEPTION;
    	break;
    	case 'oncreate':
    	case ClearChannel.AjaxEvent.prototype.ONCREATE.toLowerCase():
    		t = ClearChannel.AjaxEvent.prototype.ONCREATE;
    	break;
    	default:
    		//it doesn't match, use catchall that never gets thrown
    		t = 'AJAXEVENT';    	
    	}
    	ClearChannel.Event.call(this, t, false, true);
    	var _responseObject = responseObj || new ClearChannel.AjaxResponse();
    	this.getResponseObject = function(){
    		return _responseObject; 
    	};
    };
    ClearChannel.AjaxEvent.prototype=(function(){return new ClearChannel.Event();})();
    //public static AjaxEvent types--DO NOT CHANGE THESE AT RUNTIME OR YOU WILL INCUR MY WRATH
    /* TODO USE ClearChannel.copy to attach these to the prototype so that people don't know that u can
     * automagically change them.
     * */
    ClearChannel.AjaxEvent.prototype.SUCCESS = 'request_success';//2xx server status
	ClearChannel.AjaxEvent.prototype.OK = 'request_200';//server status 200  THE MAIN ONE TO KNOW!
	ClearChannel.AjaxEvent.prototype.CREATED = 'request_201';//server status 201
	ClearChannel.AjaxEvent.prototype.ACCEPTED = 'request_202';//server status 202
	ClearChannel.AjaxEvent.prototype.PARTIAL_INFORMATION = 'request_203';//server status 203
	ClearChannel.AjaxEvent.prototype.NO_RESPONSE = 'request_204';//server status 204
	ClearChannel.AjaxEvent.prototype.FAILURE = 'request_failure';//error 4xx, 5xx server status    	
	ClearChannel.AjaxEvent.prototype.BAD_REQUEST = 'request_400';//server status 400
	ClearChannel.AjaxEvent.prototype.UNAUTHORIZED = 'request_401';//server status 401
	ClearChannel.AjaxEvent.prototype.PAYMENT_REQUIRED = 'request_401';//server status 402
	ClearChannel.AjaxEvent.prototype.FORBIDDEN = 'request_403';//server status 403
	ClearChannel.AjaxEvent.prototype.NOT_FOUND = 'request_404';//server status 404
	ClearChannel.AjaxEvent.prototype.INTERNAL_ERROR = 'request_500';//server status 500
	ClearChannel.AjaxEvent.prototype.NOT_IMPLEMENTED = 'request_501';//server status 501
	ClearChannel.AjaxEvent.prototype.SERVICE_TEMPORARILY_OVERLOADED = 'request_502';//server status 502
	ClearChannel.AjaxEvent.prototype.GATEWAY_TIMEOUT = 'request_503';//server status 503
	ClearChannel.AjaxEvent.prototype.REDIRECTION = 'request_redirected';//server status 3xx
	ClearChannel.AjaxEvent.prototype.MOVED = 'request_301';//server status 301
	ClearChannel.AjaxEvent.prototype.FOUND = 'request_302';//server status 302
	ClearChannel.AjaxEvent.prototype.METHOD = 'request_303';//server status 303
	ClearChannel.AjaxEvent.prototype.NOT_MODIFIED = 'request_304';//server status 304
	ClearChannel.AjaxEvent.prototype.UNINITIALIZED = 'request_uninitialized';//not garaunteed to fire, but it happens when the XHR was just created
	ClearChannel.AjaxEvent.prototype.LOADING = 'request_loading';//not garaunteed to fire, but happens when the XHR object is being set up and its connection opened
	ClearChannel.AjaxEvent.prototype.LOADED = 'request_loaded';//not garaunteed to fire, but happens when the XHR object is setup, opened, and ready to send a request
	ClearChannel.AjaxEvent.prototype.INTERACTIVE = 'request_interactive';//not garaunteed to fire, but fires when the requester recieves part of the response that is not the final part that should be sent in several packets
	ClearChannel.AjaxEvent.prototype.COMPLETE = 'request_complete';//fired when a request is completed, including status specific callbacks
	ClearChannel.AjaxEvent.prototype.EXCEPTION = 'request_exception';//if there is an error, this is fired
	ClearChannel.AjaxEvent.prototype.ONCREATE ='request_object_created';
	//extends ClearChannel.EventDispatcher
	ClearChannel.Ajax = function(optionsObj, url){
		ClearChannel.EventDispatcher.call(this);
		this.name ='ClearChannel.Ajax';
		//retrieve the listeners array as a private property of this.
		var _listeners = this.getListeners();
		//overloaded to ensure Ajax listeners are used
		this.addEventListener = function(event_type, call_back, object){
    		if(!this.hasEventListener(event_type, call_back, object)){	
    			_listeners.push(new ClearChannel.AjaxListener(event_type, call_back, object));
    		}
    	};
		var _requstObject = this;
		var _complete = false;
		var _requestUrl = url.replace(/[?]/g) || "";
		var parseOptionsObject = function(){
    		var optionsReturnObject = {
    				method:ClearChannel.Ajax.prototype.GET_METHOD,
    				asynchronous: true,
    				contentType:'application/x-www-form-urlencoded',
    				encoding:'UTF-8',
    				parameters:{},
    				evalJSON:true,
    				evalJS:true,
    				sanitizeJSON:true
    		};// End local general object optionsReturnObject
    		for(var prop in optionsObj){
    			switch(prop.toLowerCase()){
    			case 'method':
    				//Begin IF- check options method
    				if(optionsObj[prop].toUpperCase() != optionsReturnObject.method && optionsObj[prop].toUpperCase() == ClearChannel.Ajax.POST_METHOD){
    					optionsReturnObject.method = ClearChannel.Ajax.POST_METHOD;
    				}//End IF-check options method
    			break;
    			case 'asynchronous':
    				//Begin IF - check options asynchronous
    				if(optionsObj[prop] != optionsReturnObject.asynchronous && typeof optionsObj[prop] == 'boolean'){
    					optionsReturnObject.asynchronous = optionsObj[prop];
    				}//ENDIF - check options asynchronous
    			break;
    			case 'contentType':
    				if(optionsObj[prop] != optionsReturnObject.contentType && typeof optionsObj[prop] == 'string'){
    					optionsReturnObject.contentType = optionsObj[prop];
    				}
    			break;
    			case 'encoding':
    				if(optionsObj[prop] != optionsReturnObject.encoding && typeof optionsObj[prop] == 'string'){
    					optionsReturnObject.encoding = optionsObj[prop];
    				}
    			break;
    			case 'parameters':
    				if(typeof optionsObj[prop] == 'object'){
    					for(var param in optionsObj[prop]){
    						if(typeof optionsObj[prop][param]=='string'){
    							optionsReturnObject.parameters[param] = escape(optionsObj[prop][param]);
    						}else if(typeof optionsObj[prop][param]=='number'){
    							optionsReturnObject.parameters[param] = escape(optionsObj[prop][param]);
    						}
    					}
    				}
        		break;
    			case 'evaljson':
    				if(optionsObj[prop] != optionsReturnObject.evalJSON && typeof optionsObj[prop] == 'boolean'){
    					optionsReturnObject.evalJSON = optionsObj[prop];
    				}
            	break;
    			case 'evaljs':
    				if(optionsObj[prop] != optionsReturnObject.evalJS && typeof optionsObj[prop] == 'boolean'){
    					optionsReturnObject.evalJS = optionsObj[prop];
    				}
                break;
    			default:
    				if(optionsObj[prop] instanceof ClearChannel.AjaxListener){		
    					_requstObject.addEventListener(optionsObj[prop].getEventType(), optionsObj[prop].getCallBack(), optionsObj[prop].getObject());
    				}
    			}
    		}
    		return optionsReturnObject;
    	};// End private method - parseOptionsObject
		var _options = parseOptionsObject();
		var _CTransport = (function(){return ClearChannel.these(
    			function() {return new XMLHttpRequest()},
    			function() {return new ActiveXObject('Msxml2.XMLHTTP')},
    			function() {return new ActiveXObject('Microsoft.XMLHTTP')}	
    		) || false;})();
		var _body = '';
		var _readyState = (function(){
			readyState = 0;
			try{
				return _CTransport.readyState;
				
			}catch(e){
				return readyState;
			}
		})();
    	this.getRequestUrl=function(){
    		return _requestUrl;
    	};
    	this.getOptions = function(){
    		
    		return _options;
    	};
    	this.getTransport = function(){
    		
    		return _CTransport;
    	};
    	this.onCreatedHandler = function(event){
    		
    		ClearChannel.Ajax.prototype.activeRequestCount++;
    	};
    	this.onCompleteHandler=function(event){
    		
    		if(ClearChannel.Ajax.prototype.activeRequestCount>0){
    			ClearChannel.Ajax.prototype.activeRequestCount--;
    		}
    	};
    	var createQueryString = function(){
    		
    		var paramString = '';
    		for(var prop in _options.parameters){
    			var paramPair = '';
    			paramPair += prop+'='+_options.parameters[prop];
    			if(paramString.indexOf('=')==-1){
    				paramString += paramPair;
    			}else{
    				paramString += '&'+paramPair;
    			}
    		}
    		return paramString;
    	};
    	var makeRequest = function(){
    		
    		var params = createQueryString();
    		if(typeof _requestUrl == 'string' && _requestUrl != ''){
    			if (_options.method == ClearChannel.Ajax.prototype.GET_METHOD){
    				_requestUrl += ((_requestUrl.indexOf('?')==-1 ) ? '?' : ((_requestUrl.indexOf('?')==_requestUrl.length-1)?'':'&')) + params;
    			} else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)){
        	        params += '&_=';	
    			}
    			try{
    				var response = new ClearChannel.AjaxResponse(_requstObject);
    				_requstObject.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.ONCREATE, response));
    				
    				_CTransport.open(_options.method, _requestUrl, _options.asynchronous);
    				_CTransport.onreadystatechange = _requstObject.onStateChange.ClearChannelAnchor(_requstObject);
    				_requstObject.setRequestHeaders();
    				if(_options.method == ClearChannel.Ajax.prototype.POST_METHOD){
    					_body = (params != '')?params:null;
    				}else{
    					_body = null;
    				}
    				_CTransport.send(_body);
    				/* Force Firefox to handle ready state 4 for synchronous requests */
    				if (!_options.asynchronous && _CTransport.overrideMimeType){
    					_requstObject.onStateChange();
    				}
    			}catch(e){
    				
    				_requstObject.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, e));
    			}	
    		}else{
    			
    			_requstObject.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error('You must define a url for this request.')));
    			
    		}
    	};
    	this.setRequestHeaders = function(){
    		
    		var headers = {
    				'X-Requested-With': 'XMLHttpRequest',
    				'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
    		};
    		if (_options.method == ClearChannel.Ajax.prototype.POST_METHOD) {
    			headers['Content-type'] = this.options.contentType +(_.options.encoding ? '; charset=' + _options.encoding : '');
    			/* Force "Connection: close" for older Mozilla browsers to work
    			 * around a bug where XMLHttpRequest sends an incorrect
    			 * Content-length header. See Mozilla Bugzilla #246651.
    			 */
    			if (_CTransport.overrideMimeType && (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005){
    				headers['Connection'] = 'close';
    			}
    			// user-defined headers
    			if (typeof _options.requestHeaders == 'object') {
    				if(_options.requestHeaders instanceof Array){
    					for(var i = 0, length=_options.requestHeaders.length; i<length;i++){
    						if(typeof _options.requestHeaders[i]=='object'){
    							for(var cName in _options.requestHeaders[i]){
    	    						headers[cName]=_options.requestHeaders[i][cName];
    	    					}
    						}
    					}
    				}else{
    					for(var aName in _options.requestHeaders){
    						headers[aName]=_options.requestHeaders[aName];
    					}
    				}
    			}
    			for (var name in headers){
  			      _CTransport.setRequestHeader(name, headers[name]);
    			}
    		}
    	};
    	this.onStateChange = function(){
    		
    		var readyState = _CTransport.readyState;
    		if(!_complete){
    			this.respondToReadyState(readyState);
    		}
    	};
    	this.respondToReadyState = function(state){
    		
    		
    		var response = new ClearChannel.AjaxResponse(this);
    		
    		switch(state){
    		case 0:
    			this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.UNINITIALIZED, response));
    		break;
    		case 1:
    			this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.LOADING, response));
        	break;
    		case 2:
    			this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.LOADED, response));
        	break;
    		case 3:
    			this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.INTERACTIVE, response));
        	break;
    		case 4:
    			switch(_CTransport.status){
    			case 200:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.OK, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.SUCCESS, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.COMPLETE, response));
    			break;
    			case 201:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.CREATED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.SUCCESS, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.COMPLETE, response));
    			break;
    			case 202:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.ACCEPTED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.SUCCESS, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.COMPLETE, response));	
    			break;
    			case 203:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.PARTIAL_INFORMATION, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.SUCCESS, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.COMPLETE, response));	
    			break;
    			case 204:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.NO_RESPONSE, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.SUCCESS, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.COMPLETE, response));	
    			break;
    			case 400:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.BAD_REQUEST, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Bad Server Request')));
    			break;
    			case 401:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.UNAUTHORIZED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Unauthorized Access Attempt')));
    			break;
    			case 402:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.PAYMENT_REQUIRED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Payment Required for Access')));
    			break;
    			case 403:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FORBIDDEN, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':You are forbidden to Access')));
    			break;
    			case 404:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.NOT_FOUND, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':File Not Found')));
    			break;
    			case 500:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.INTERNAL_ERROR, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Server Error')));
    			break;
    			case 501:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.NOT_IMPLEMENTED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Server Error')));
    			break;
    			case 502:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.SERVICE_TEMPORARILY_OVERLOADED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Server Temporary Timeout')));
    			break;
    			case 503:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.GATEWAY_TIMEOUT, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Server Timeout')));
    			break;
    			case 301:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.MOVED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.REDIRECTION, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Service Moved')));
    			break;
    			case 302:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FOUND, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.REDIRECTION, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Service Moved, but Found')));
    			break;
    			case 303:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.METHOD, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.REDIRECTION, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':Service Method not allowed')));
    			break;
    			case 304:
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.NOT_MODIFIED, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.REDIRECTION, response));
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.FAILURE, response));
    				_complete=true;
    				this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, new Error(_requestUrl+':File Not Modified Since Last Access')));
    			break;
    			default: '';
    			}
        	break;
    		default: '';
    		}
    		
    	};
    	this.isSameOrigin=function(){
    		
    		var m = _requestUrl.match(/^\s*https?:\/\/[^\/]*/);
    		return !m || (m[0] == location.protocol+'//'+document.domain+((location.port)?location.port:''));    		
    	};
    	this.dispatchException=function(exception){
    		
    		this.dispatchEvent(new ClearChannel.AjaxEvent(ClearChannel.AjaxEvent.prototype.EXCEPTION, exception));
    	};
    	this.addEventListener(ClearChannel.AjaxEvent.prototype.ONCREATE, this.onCreatedHandler, this);
		this.addEventListener(ClearChannel.AjaxEvent.prototype.EXCEPTION, this.onCompleteHandler, this);
		this.addEventListener(ClearChannel.AjaxEvent.prototype.COMPLETE, this.onCompleteHandler, this);
    	if(_requestUrl != ''){
    		makeRequest();
    	}
	};
	ClearChannel.Ajax.prototype = (function(){return new ClearChannel.EventDispatcher();})();
	ClearChannel.Ajax.prototype.activeRequestCount = 0;
	ClearChannel.Ajax.prototype.activeRequestQueue = ClearChannel.Array();
	ClearChannel.Ajax.prototype.POST_METHOD = 'POST';
	ClearChannel.Ajax.prototype.GET_METHOD = 'GET';
	ClearChannel.AjaxResponse = function(request){
		
		this.isJSON=function(JSONString){
			
			if (JSONString == '' || typeof JSONString == 'undefined' || JSONString==null ){
				return false;
			}
		    var str = JSONString.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
		    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
		};
		this.unfilterJSON = function(JSON, filter){
			
			return JSON.replace(filter || ClearChannel.JSONFilter, '#{1}');
		};
		this.evalJSON = function(filterJSON, JSONString){
			
			JSONString = this.unfilterJSON(JSONString);
			try {
				if (!filterJSON || this.isJSON(JSONString)){
					return eval('(' + JSONString + ')');
				}
			} catch (e) {
				throw new SyntaxError('Badly formed JSON string');
			}
		};
		var _responseObject = this;
		var _request = (function(){
			
			if(request instanceof ClearChannel.Ajax){
				return request;
			}else{
				return new ClearChannel.Ajax();
			}
		})();
		var _CTransport = _request.getTransport();
		var _readyState = (function(){try{return _CTransport.readyState;}catch(e){return 0;}})();
		var _status = (function(){
			try {
			      return _CTransport.status || 0;
		    } catch (e) { 
		    	return 0; 
		    }
		})();
		var _statusText = (function(){
			try {
				return _CTransport.statusText || '';
			} catch (e) {
				return '';
			}
		})();
		var _responseText = (function(){
			try{
				return ClearChannel.castToString(_CTransport.responseText);
			}catch(e){
				return '';
			}
		})();
		var _headerJSON = (function(){
			if(_readyState == 4){
				var json = (function(){
					try{
						return _CTransport.getResponseHeader('X-JSON');
					}catch(e){
						return false;
					}
				})();
			    if (!json) return null;
			    json = decodeURIComponent(escape(json));
			    try {
			    	return _responseObject.evalJSON(_request.getOptions().sanitizeJSON || _request.isSameOrigin(), json);
			    } catch (e) {
			      _request.dispatchException(e);
			    }
			}else{
				return {};
			}
		})();
		var _responseXML = (function(){
			if(_readyState==4){
				try{
				
				var xml = _CTransport.responseXML;
			      return (typeof xml == 'undefined') ? null : xml;
				}catch(e){
					return false;
				}
			
			}else{
				return false;
			}
		})();
		var _responseJSON = (function(){
			if(_readyState == 4){
				var options = _request.getOptions();
				var contentTypeHeader = _CTransport.getResponseHeader('Content-type');
			    if (contentTypeHeader == null || !options.evalJSON || (options.evalJSON != 'force' && !(contentTypeHeader != '' && contentTypeHeader.indexOf('')!=-1) || (typeof _responseText == 'undefined' || _responseText == null || _responseText == ''))){
			          return null;
			    }
			    try {
			      return _responseObject.evalJSON(options.sanitizeJSON ||
			        !_request.isSameOrigin(), _responseText);
			    } catch (e) {
			      _request.dispatchException(e);
			    }
			}else{
				return {};
			}
		})();
		this.getRequest = function(){
			
			return _request;
		};
		this.getTransport = function(){
			
			return _CTransport;
		};
		this.getReadyState = function(){
			
			return _readyState;
		};
		this.getStatus=function(){
			
			return _status;
		};
		this.getStatusText = function(){
			
			return _statusText;
		};
		this.getResponseText = function(){
			
			return _responseText;
		};
		this.getHeaderJSON = function(){
			
			return _headerJSON;
		};
		this.getResponseXML = function(){
			
			return _responseXML;
		};
		this.getResponseJSON = function(){
			
			return _responseJSON;
		};
		this.retrieveResponseHeader=function(name){
			
			if(_readyState!=0){
			var responseHeader = null;
			try{
				responseHeader = _CTransport.getResponseHeader(name);
			}catch(e){
				return null;
			}
			return responseHeader;
			}else{
				return '';
			}
		};
		this.retrieveAllResponseHeaders = function(){
			
			var responseHeaders = null;
			  try{
				  responseHeaders = _CTransport.getAllResponseHeaders();
			  }catch(e){
				  
			  }
			  return responseHeaders;
		};
	};
})();