ÿþ/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,

  eqeqeq: true, plusplus: true, bitwise: true, regexp: true, immed: true */



/*global window: false */



/*members FusionCharts, args, attributes, class, constructor, core,

    extend, getObjectReference, height, id, insertMode, items, lang, lastId,

    length, options, overlayButton, parsePolicies, policies, product,

    prototype, raiseError, raiseEvent, raiseWarning, resizeTo, safeMode,

    src, swfUrl, toString, uniqueId, version, width, ref, __state

*/



/*!

 * FusionCharts JavaScript Library

 * Copyright FusionCharts Technologies LLP

 * License Information at <http://www.fusioncharts.com/license>

 *

 * @author FusionCharts

 * @version 3.2.1-release

 *

 * Third-party attributions:

 * SWFObject v2.2 <http://code.google.com/p/swfobject/>

 * JSON v2 <http://www.JSON.org/js.html>

 * Firebug Lite 1.3.0 <http://getfirebug.com/firebuglite>

 * jQuery 1.4.2 <http://jquery.com/>

 */



/**

 * -----------------------------------------------------------------------------

 * FusionCharts Core Framework

 * FusionCharts core framework module. This module contains the basic routines

 * required by subsequent modules to extend/scale or add functionality to the

 * FusionCharts object.

 * -----------------------------------------------------------------------------

 */

(function () {



    // In case FusionCharts o

    // bject already exists, we skip this function.

    if (typeof window.FusionCharts !== 'undefined') {

        return;

    }



    /**

     * @var {object} global The global variable would store all private methods

     * and properties available to each module.

     *

     * @var {object} modules For maintaining module information.

     *

     * @var {Array} argsT Specifies the order in which the parameters of the new

     * FusionCharts objects are interpreted and converted to options object.

     */

    var global = {}, modules = {}, argsT = ['swfUrl', 'id', 'width', 'height',

        'debugMode', 'registerWithJS', 'bgColor', 'scaleMode', 'lang',

        'detectFlashVersion', 'autoInstallRedirect'];



    /**

     * This method, when added to the prototype of an object,

     * allows shallow or deep extension of the object with another

     * object.

     */

    global.extend = function (obj1, obj2) {



        // Get shallow or deep copy information

        var deep = typeof arguments[arguments.length - 1] === 'boolean' ?

            arguments[arguments.length - 1] : false;



        // Decide which parameter is going to be source and which one will be

        // sink.

        var src = obj2, snk = obj1;

        if (typeof obj2 === 'boolean' || arguments.length === 1) {

            snk = global.core;

            src = obj1;

        }

        // When 'shallow' is marked as true, the methods and properties

        // of source is not added to the prototype of the sink.

        if (deep === true) {

            snk = snk.prototype;

        }



        // Copy all methods and properties of the object passed in parameter

        // to the object to which this function is attached.

        for (var item in src) {

            snk[item] = src[item];

        }



        return snk;

    };



    // Function that auto-generates a unique id.

    global.uniqueId = function () {

        return 'chartobject-' + (global.uniqueId.lastId += 1);

    };

    global.uniqueId.lastId = 0;



    // Define the policy to create default parameters for the swfObject.

    // Values are in format [sourceOption, defaultValue]

    // This helps in building the initial FusionCharts object when new instances

    // are created from user parameters.

    global.policies = {

        /**

         * @var options {object} Contains all the customizable options that are

         * used by the library internally and has nothing to do with renderer

         * attributes, vars or parameters

         */

        options: {

            product: ['product', 'v3'],

            insertMode: ['insertMode', 'replace'],

            safeMode: ['safeMode', true],

            overlayButton: ['overlayButton', undefined]

        },

        /**

         * @var attributes {object} Contains configurations pertaining to the

         * host (browser) environment.

         */

        attributes: {

            lang: ['lang', 'EN'],

            'class': ['className', 'FusionCharts']

        },



        /**

         * @var {Array} width configuration for width of the chart.

         * @var {Array} height configuration for height of the chart.

         * @var {Array} src specifies chart swf url

         */

        width: ['width', '400'],

        height: ['height', '300'],

        src: ['swfUrl', ''],

        

        __state: {}

    };



    /**

     * Allows the core to process an arguments object based on a set of policies

     * and construct an object out of it that is mapped exactly as respective

     * parameter policy defines. In other words, it uses an object and

     * creates another object or updates another object with values from the

     * original arguments object in a particular hierarchy and name that a set

     * of rules (policies) define.

     */

    global.parsePolicies = function (obj, policies, options) {

        var prop, policy, value;



        // Iterate through the data policy and correspondingly create the

        // three stacks of parameters, attributes and flashVars

        for (policy in policies) {



            // Set just the policy object in case of single-level policy.

            if (global.policies[policy] instanceof Array) {

                value = options[policies[policy][0]];

                obj[policy] = value === undefined ? policies[policy][1] : value;

                continue;

            }



            // Define objects that would hold parameters for swfobject. Also

            // populate with variables from the parameters

            if (typeof obj[policy] !== 'object') {

                obj[policy] = {};

            }



            // Set every sub-object for two-level policy

            for (prop in policies[policy]) {

                value = options[policies[policy][prop][0]];

                obj[policy][prop] = value === undefined ? 

                    policies[policy][prop][1] : value;

            }

        }

    };

    

    global.core = function (command) {

        // This point onwards, we must check whether this is being used as a

        // constructor or not

        if (!(this instanceof global.core)) {

            // Allow private communication with modules. In case FusionCharts is

            // not called as constructor and it is passed an array that is marked

            // to do private communication, then share the global variable.

            if (arguments.length === 1 &&

                command instanceof Array && command[0] === 'private') {

                // Prevent overwriting and duplicate execution of modules.

                if (modules[command[1]] === true) {

                    return undefined;

                }

                modules[command[1]] = true;

                return global;

            }



            // Allow using FusionCharts object to directly access its new items

            if (arguments.length === 1 && typeof command === 'string') {

                return global.core.items[command];

            }

            // In case all above combination of arguments fail, we can unsafely

            // assume that user forgot the 'new' keyword.

            global.raiseError(this, '25081840', 'run', '', new SyntaxError(

                "Use the \"new\" keyword while creating a new FusionCharts object"));

        }



        // Define a variable for iterative key in various loops and the

        // object variable that stores the options.

        var options = {}, prop;



        // Check whether linear arguments are sent and convert it to object.

        if (arguments.length === 1 && typeof arguments[0] === 'object') {

            // If the above condition matches, then we can safely assume that

            // the first parameter is the options object.

            options = arguments[0];

        }

        else {

            // Iterate through the arguments template and add the keys to the

            // options object while fetching corresponding values from arguments

            // array.

            for (prop in argsT) {

                options[argsT[prop]] = arguments[prop];

            }

        }



        // Incorporate the trailing object parameter as object-style

        // parameter input overrides.

        if (typeof arguments[arguments.length - 1] === 'object') {

            delete options[arguments.length - 1];

            global.extend(options, arguments[arguments.length - 1]);

        }



        // Set autogenerated chart-id in case one is not specified

        this.id = typeof options.id === 'undefined' ?

            this.id = global.uniqueId() : options.id;



        // Set dimension passed by user and subsequently validate the options.

        // - Remove trailing 'px'

        this.args = options;



        // If an item is created with same id, the previous item is disposed.

        if (global.core.items[this.id] instanceof global.core) {

            this.id = global.uniqueId();

            global.raiseWarning(this, '06091847', 'param', '',

                'A FusionChart oject with the specified id \"' + this.id +

                '\" already exists. Renaming it to ' + this.id);

        }

        

        // Parse global policies.

        global.parsePolicies(this, global.policies, options);



        // Set initial dimension of charts

        this.resizeTo(options.width, options.height, true);

        

        // Execute all constructors one after the other using events.

        global.raiseEvent('BeforeInitialize', options, this);



        // Add this object to the repository of objects within core object.

        global.core.items[this.id] = this;



        // Raise initialization event.

        global.raiseEvent('Initialized', options, this);



        return this;

    };



    // Make the core extensible and reset the constructor of the object

    // for maintaining correct prototype chain.

    global.core.prototype = {};

    // Reset constructor.

    global.core.prototype.constructor = global.core;



    global.extend({

        id: 'FusionCharts',

        /**

         * The version of FusionCharts.js

         */

        version: [3, 2, 1, 'release', 1750],



        // Add a container of all chart objects. This will allow easy returning

        // of FusionCharts objects through getChartFromId.

        items: {},



        // Add an object to store options

        options: {},

        

        // Add function to access the object created by renderers.

        getObjectReference: function (id) {

            return global.core.items[id].ref;

        }

    }, false);



    // Expose the core to the global scope.

    window.FusionCharts = global.core;



}());







/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,

  eqeqeq: true, plusplus: true, bitwise: true, regexp: true, immed: true */



/*global Array: false, FusionCharts, window: false */



/*members "*", BeforeDispose, BeforeInitialize, DataLoadCancelled, BeforeDataUpdate,

    DataLoadError, DataLoadRequestCancelled, DataLoadRequestCompleted, DataUpdateCancelled,

    DataLoadRequested, DataLoaded, DataXMLInvalid, Disposed, DrawComplete,

    FusionChartsEvents, Initialized, InvalidDataError, Loaded, DataUpdated

    NoDataToDisplay, Rendered, Resized, addEventListener, addListener, call,

    cancel, core, eventId, eventType, extend, items, lastEventId, length,

    listeners, push, raiseError, raiseEvent, removeEventListener,

    removeListener, sender, splice, stopPropagation, toLowerCase,

    triggerEvent

*/



/**

 * -----------------------------------------------------------------------------

 * Event Handler Framework

 * This module allows FusionCharts to work with W3C Level 2 style events for

 * allowing multiple handlers per event and also to do event driven development

 * on a global or per-chart basis.

 * -----------------------------------------------------------------------------

 */

(function () {



    // Try register the module with FusionCharts.

    var global = FusionCharts(['private', 'EventManager']);

    // Check whether the module has been already registered. If true, then

    // do not bother to re-register.

    if (global === undefined) {

        return;

    }



    // Collection of FusionCharts events

    window.FusionChartsEvents = {

        BeforeInitialize: 'beforeinitialize',

        Initialized: 'initialized',

        Loaded: 'loaded',

        Rendered: 'rendered',

        DataLoadRequested: 'dataloadrequested',

        DataLoadRequestCancelled: 'dataloadrequestcancelled',

        DataLoadRequestCompleted: 'dataloadrequestcompleted',

        BeforeDataUpdate: 'beforedataupdate',

        DataUpdateCancelled: 'dataupdatecancelled',

        DataUpdated: 'dataupdated',

        DataLoadCancelled: 'dataloadcancelled',

        DataLoaded: 'dataloaded',

        DataLoadError: 'dataloaderror',

        NoDataToDisplay: 'nodatatodisplay',

        DataXMLInvalid: 'dataxmlinvalid',

        InvalidDataError: 'invaliddataerror',

        DrawComplete: 'drawcomplete',

        Resized: 'resized',

        BeforeDispose: 'beforedispose',

        Disposed: 'disposed'

    };



    // A function to create an abstraction layer so that the try-catch /

    // error suppression of flash can be avoided while raising events.

    var managedFnCall = function (item, scope, event, args) {

        // We change the scope of the function with respect to the

        // object that raised the event.

        try {

            item[0].call(scope, event, args || {});

        }

        catch (e) {

            // Call error in a separate thread to avoid stopping

            // of chart load.

            setTimeout(function () { 

                throw e;

            }, 0);

        }

    };



    // Function that executes all functions that are to be invoked upon trigger

    // of an event.

    var slotLoader = function (slot, event, args) {

        // If slot does not have a queue, we assume that the listener

        // was never added and halt method.

        if (!(slot instanceof Array)) {

            // Statutory W3C NOT preventDefault flag

            return;

        }

        

        // Initialize variables.

        var i = 0, scope;



        // Iterate through the slot and look for match with respect to

        // type and binding.

        for (; i < slot.length; i += 1) {



            // If there is a match found w.r.t. type and bind, we fire it.

            if (slot[i][1] === event.sender || slot[i][1] === undefined) {



                // Determine the sender of the event for global events.

                // The choice of scope differes depending on whether a

                // global or a local event is being raised.

                scope = slot[i][1] === event.sender ?

                    event.sender : global.core;



                managedFnCall(slot[i], scope, event, args);

            }



            // Check whether propagation flag is set to false and discontnue

            // iteration if needed.

            if (event.cancel === true) {

                break;

            }

        }

    };



    var EventTarget = {



        // Entire collection of listeners.

        listeners: {},



        // The last raised event id. Allows to calculate the next event id.

        lastEventId: 0,



        addListener: function (type, listener, bind) {



            // In case type is sent as array, we recurse this function.

            if (type instanceof Array) {

                // We look into each item of the 'type' parameter and send it,

                // along with other parameters to a recursed addListener

                // method.

                for (var i = 0; i < type.length; i += 1) {

                    EventTarget.addListener(type[i], listener, bind);

                }

                return;

            }



            // Validate the type parameter. Listener cannot be added without

            // valid type.

            if (typeof type !== 'string') {

                global.raiseError(this, '03091549', 'param', '::EventTarget.addListener',

                    new Error('Unspecified Event Type'));

                return;

            }



            // Listener must be a function. It will not eval a string.

            if (typeof listener !== 'function') {

                global.raiseError(this, '03091550', 'param', '::EventTarget.addListener',

                    new Error('Invalid Event Listener'));

                return;

            }



            // Desensitize the type case for user accessability.

            type = type.toLowerCase();



            // If the insertion position does not have a queue, then create one.

            if (!(EventTarget.listeners[type] instanceof Array)) {

                EventTarget.listeners[type] = [];

            }



            // Add the listener to the queue.

            EventTarget.listeners[type].push([listener, bind]);



        },



        removeListener: function (type, listener, bind) {

		

			var i;

		

            // In case type is sent as array, we recurse this function.

            if (type instanceof Array) {

                // We look into each item of the 'type' parameter and send it,

                // along with other parameters to a recursed addListener

                // method.

                for (i = 0; i < type.length; i += 1) {

                    EventTarget.removeListener(type[i], listener, bind);

                }

                return;

            }



            // Validate the type parameter. Listener cannot be removed without

            // valid type.

            if (typeof type !== 'string') {

                global.raiseError(this, '03091559', 'param', '::EventTarget.removeListener',

                    new Error('Unspecified Event Type'));

                return;

            }



            // Listener must be a function. Else we have nothing to remove!

            if (typeof listener !== 'function') {

                global.raiseError(this, '03091560', 'param', '::EventTarget.removeListener',

                    new Error('Invalid Event Listener'));

                return;

            }



            // Desensitize the type case for user accessability.

            type = type.toLowerCase();



            // Create a reference to the slot for easy lookup in this method.

            var slot = EventTarget.listeners[type];



            // If slot does not have a queue, we assume that the listener

            // was never added and halt method.

            if (!(slot instanceof Array)) {

                return;

            }



            // Iterate through the slot and remove every instance of the

            // event handler.

            for (i = 0; i < slot.length; i += 1) {

                // Remove all instances of the listener found in the queue.

                if (slot[i][0] === listener && slot[i][1] === bind) {

                    slot.splice(i, 1);

                    i -= 1;

                }

            }

        },



        // opts can have { async:true, omni:true }

        triggerEvent: function (type, sender, args) {



            // In case, event type is missing, dispatch cannot proceed.

            if (typeof type !== 'string') {

                global.raiseError(this, '03091602', 'param', '::EventTarget.dispatchEvent',

                    new Error('Invalid Event Type'));

                return undefined;

            }



            // Desensitize the type case for user accessability.

            type = type.toLowerCase();

            

            // Model the event as per W3C standards. Add the function to cancel

            // event propagation by user handlers. Also append an incremental

            // event id.

            var event = {

                eventType: type,

                eventId: (EventTarget.lastEventId += 1),

                sender: (typeof sender === 'string' ?

                    global.core.items[sender] : sender),

                stopPropagation: function () {

                    return (this.cancel = true) === false;

                }

            };



            // Execute the functions present within the event slot (collection

            // of functions for a particular event).

            slotLoader(EventTarget.listeners[type], event, args);

            

            // Facilitate the call of a global event listener.

            slotLoader(EventTarget.listeners['*'], event, args);



            // Statutory W3C NOT preventDefault flag

            return true;

        }

    };



    // Facilitate for raising events internally.

    global.raiseEvent = function (type, args, obj) {

        return EventTarget.triggerEvent(type,

            (obj === undefined ? global.core : obj), args);

    };



    // Extend the eventlisteners to internal global.

    global.addEventListener = function (type, listener) {

        return EventTarget.addListener(type, listener);

    };

    global.removeEventListener = function (type, listener) {

        return EventTarget.removeListener(type, listener);

    };



    // Add eventListener extensibility to FusionCharts object

    global.extend({

        addEventListener: global.addEventListener,

        removeEventListener: global.removeEventListener

    }, false);



    // Add eventListener extensibility to FusionCharts prototype so that

    // individual FusionCharts objects can use per-chart events

    global.extend({

        addEventListener: function (type, listener) {

            return EventTarget.addListener(type, listener, this);

        },

        removeEventListener: function (type, listener) {

            return EventTarget.removeListener(type, listener, this);

        }

    }, true);



    // Cleanup on dispose

    global.addEventListener('BeforeDispose', function (e) {

        var type, i;

        // Iterate through all events in the collection of listeners

        for (type in EventTarget.listeners) {

            for (i = 0; i < EventTarget.listeners[type].length; i += 1) {

                // When a match is found, delete the listener from the

                // collection.

                if (EventTarget.listeners[type][i][1] === e.sender) {

                    EventTarget.listeners[type].splice(i, 1);

                }

            }

        }

    });



}());







/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,

  eqeqeq: true, plusplus: true, bitwise: true, regexp: true, immed: true */



/*global Array: false, FusionCharts, window: false, console: false */



/*members _enableFirebugLite, appendChild, comp, console, core,

    createElement, currentOutputHelper, debugMode, enabled, event, eventId,

    eventType, extend, firebug, getElementsByTagName, id, impl, length,

    level, log, message, module, name, nature, onload, onreadystatechange,

    options, outputFailed, outputFormat, outputHandler, outputHelpers,

    outputTo, param, raiseError, raiseEvent, raiseWarning, range,

    readyState, run, scriptBaseUri, sender, setTimeout, source, src, text,

    toLowerCase, toString, type, undefined, verbose

*/



/**

 * -----------------------------------------------------------------------------

 * FusionCharts JavaScript Library

 * Error Handler Framework

 *

 * This module allows other FusionCharts JavaScript Library modules to raise

 * error and warning messages.

 * -----------------------------------------------------------------------------

 */

(function () {



    // Try register the module with FusionCharts.

    var global = FusionCharts(['private', 'ErrorHandler']);

    // Check whether the module has been already registered. If true, then

    // do not bother to re-register.

    if (global === undefined) {

        return;

    }



    // Set the default options for the default output helper.

    var DEFAULT_OUTPUT_HELPER = 'text';



    /**

     * @var {object} errorNature is an enumeration containing possible error

     * types. This is used so that shorthand reference to .raiseError and

     * .raiseWarning can be expanded for easier user reference.

     */

    var errorNatures = {

        type: 'TypeException',

        range: 'ValueRangeException',

        impl: 'NotImplementedException',

        param: 'ParameterException',

        run: 'RuntimeException',

        comp: 'DesignTimeError',

        'undefined': 'UnspecifiedException'

    };





    /**

     * This function raises the error event after appropriately formatting the

     * parameters.

     * @param {FusionCharts} sender

     * @param {string} id Is the error reference id.

     * @param {string} nature Is a cue as to what category of error is this.

     *         The value of this param must be same as one of the "keys" within

     *         the "errorNatures" collection.

     * @param {string} source Is a cue as to which object/module caused this

     *         error.

     * @param {Error} err

     * @param {string} level Indicates whether this error event is an error

     *         or warning event. Its values can be "Error" or "Warning".

     *

     * @type void

     */

    var raiseEWEvent = function (sender, id, nature, source, err, level) {



        // We create a human-readable message for this error.

        var message = '#' + id + ' ' + sender.id + source + ' ' + level + ' >> ';



        // If err is sent as error object, we input more details to the error

        // object

        if (err instanceof Error) {

            err.name = errorNatures[nature];

            err.module = 'FusionCharts' + source;

            err.level = level;



            // Update the error message.

            err.message = message + err.message;

            message = err.message;

            

            // Throw error in a separate scope so that the execution of this script

            // is not blocked. Do this only when debugMode is enabled

            window.setTimeout(function () {

                throw err;

            }, 0);



        }

        else {

            // Append the message string to the error message and sync with err.

            message = message + err;

        }



        // Prepare the event argument object.

        var args = {

            id: id,

            nature: errorNatures[nature],

            source: 'FusionCharts' + source,

            message: message

        };

        // Raise the appropriate event.

        global.raiseEvent(level, args, sender);



        // Raise legacy events

        if (typeof window['FC_' + level] === 'function') {

            window['FC_' + level](args);

        }



    };



    /**

     * This function raises an "Error" event based upon the parameters passed

     * to it.

     * @param {FusionCharts} sender

     * @param {string} id Is the error reference id.

     * @param {string} nature Is a cue as to what category of error is this.

     *         The value of this param must be same as one of the "keys" within

     *         the "errorNatures" collection.

     * @param {string} source Is a cue as to which object/module caused this

     *         error.

     * @param {string} message

     *

     * @type void

     */

    global.raiseError = function (sender, id, nature, source, message) {

        raiseEWEvent(sender, id, nature, source, message, 'Error');

    };



    /**

     * This function raises an "Warning" event based upon the parameters passed

     * to it.

     * @param {FusionCharts} sender

     * @param {string} id Is the error reference id.

     * @param {string} nature Is a cue as to what category of error is this.

     *         The value of this param must be same as one of the "keys" within

     *         the "errorNatures" collection.

     * @param {string} source Is a cue as to which object/module caused this

     *         error.

     * @param {string} message

     *

     * @type void

     */

    global.raiseWarning = function (sender, id, nature, source, message) {

        raiseEWEvent(sender, id, nature, source, message, 'Warning');

    };



    /**

     * @var {object} logger Conatins all routines pertaining to logging a debug

     * outout.

     */

    var logger = {

        /**

         * @var {object} outputHelpers Is the collection of functions that calls

         * the outputTo function with arguments formatted in a specific manner.

         */

        outputHelpers: {

            // Simple text output function.

            'text': function (e, a) {

                var sender = (e.sender.id || e.sender).toString();

                logger.outputTo('#' + e.eventId + ' [' + sender + '] fired "' +

                    e.eventType + '" event. ' + (e.eventType === 'error' ||

                    e.eventType === 'warning' ? a.message : ''));

            },

            // Function that calls the debugger method in typical FusionCharts

            // events argument format.

            'event': function (e, a) {

                this.outputTo(e, a);

            },

            // This function formats outputs with all details, and still,

            // maintaining human readable format. It is best used in conjunction

            // with an advanced JS console.

            'verbose': function (e, a) {

                logger.outputTo(e.eventId, e.sender.id, e.eventType, a);

            }

        },



        /**

         * @var {object} outputHandler Is the eventHandler that indirectly calls

         * the output function via output helpers whenever any event is raised.

         */

        outputHandler: function (e, a) {

            // Verify whether the output function exists or not.

            if (typeof logger.outputTo !== 'function') {

                global.core.debugMode.outputFailed = true;

                return;

            }

            // Clear flag of data load fail upon reaching this line.

            global.core.debugMode.outputFailed = false;

            // Call the current outputHelper in order to invoke the

            // required function.

            logger.currentOutputHelper(e, a);

        },



        /**

         * @var {function} currentOutputHelper Is the function that formats the

         * debug output if event format to different formats as arguments.

         * @var {function} outputTo Is the reference to the function that is

         * called when a debug event is raised.

         * @var {boolean} keeps a track whether the logger is enabled or not.

         */

        currentOutputHelper: undefined,



        outputTo: undefined,



        enabled: false

    };



    // Set the initial default output helper to the one specified as default.

    logger.currentOutputHelper = logger.outputHelpers[DEFAULT_OUTPUT_HELPER];



    // Add debugMode API to FusionCharts core object, so that it can be accessed

    // by users globally.

    global.extend({

        debugMode: {

            /**

             * Specifies how to format the output to the function that will

             * accept output from the debugger.

             * @id FusionCharts.debugMode.outputFormat

             *

             * @param {string} format Can be one of the accepted format names

             * such as "text", "verbose", "event".

             *

             * @type boolean

             */

            outputFormat: function (format) { 

                // Validate the parameter.

                if (format && typeof format.toLowerCase === 'function' &&

                    typeof logger.outputHelpers[format = format.toLowerCase()] === 'function') {

                    // set the current output helper function to the one specified

                    // in parameter

                    logger.currentOutputHelper = logger.outputHelpers[format];

                    // Return "true" to users, indicating, output format

                    // successfully updated.

                    return true;

                }

                // In case validation fails, notify user that it failed by

                // returning false;

                return false;

            },



            /**

             * Allows you to specify the function to which the debugger output

             * will be redirected.

             * @id FusionCharts.debugMode.outputTo

             *

             * @param {function} fn is the function to which the debugMode output

             * will be passed on.

             *

             * @type void

             */

            outputTo: function (fn) {

                // Check whether the logger is a function or not. If it is a

                // function, we set a reference to it to be used later as the

                // logger function.

                if (typeof fn === 'function') {

                    logger.outputTo = fn;

                }

                

                // In case user sends 'null' as the value of the logger function,

                // we can assume that user wants not to log any output.

                else if (fn === null) {

                    global.core.debugMode.enabled(false);

                    delete logger.outputTo;

                }

            },



            /**

             * Enables, disables and configures the debugMode.

             * @FusionCHarts.edbugMode.enabled

             *

             * @param {boolean} state specifies whether to enable logging of

             * debug information.

             * @param {function} outputTo is the function to which the debugMode

             * output will be passed on.

             * @param {string} format Can be one of the accepted format names

             * such as "text", "verbose", "event".

             *

             * @return The current 'enable' state of the debugMode.

             * @type boolean

             */

            enabled: function (state, outputTo, format) {



                // In case user send in only one parameter and that too a

                // function, we can assume that he wants to use it as a logger

                // function and also enable logging.

                if (typeof state === 'function') {

                    if (typeof outputTo === 'string' && arguments.length === 2) {

                        format = outputTo;

                    }

                    outputTo = state;

                    state = true;

                }

                

                // In case user sends in a valid parameter to change the current

                // state of the debugger, we update the debugger state.

                if (typeof state === 'boolean' && state !== logger.enabled) {

                    global.core[(logger.enabled = state) ? 'addEventListener'

                        : 'removeEventListener']('*', logger.outputHandler);

                }



                // If user sends in a parameter for the logger parameter, we

                // set it to the logger function reference.

                if (typeof outputTo === 'function') {

                    logger.outputTo = outputTo;

                }



                // Set output format if needed.

                global.core.debugMode.outputFormat(format);



                // Finally send the current debugger state to the user.

                return logger.enabled;

            },



            /**

             * This method fetches FirebugLite component's code and adds it to

             * current page. Subsequently, on load of the script it enables

             * advanced console logging to it.

             * @id FusionCharts.debugMode._enableFirebugLite

             *

             * @param {string} url is the path to the location where the firebug

             * javascript exists.

             *

             * @type void

             * @private true

             */

            _enableFirebugLite: function (url) {

                // Check whether firebug already exists.

                if (window.console && window.console.firebug) {

                    // If firebug already exists, we do not need to include any

                    // script for firebu-lite and we simply enable logging to

                    //console.

                    global.core.debugMode.enabled(console.log, 'verbose');

                    return;

                }



                // Check for "XSS attack characters"



                // Install firebug-lite within page by creating new 'script'

                // element and appending to page head.



                // Create the element with its attributes.

                var script = document.createElement('script');

                script.type = 'text/javascript';

                script.src = typeof url === 'string' ? url :

                    global.core.options.scriptBaseUri + 'firebug-lite.js';



                // Set default configuration of firebug-lite

                script['\v' === 'v' ? 'text' : 'innerHTML'] =

                    '{ startOpened: true }';





                // Attach events to check when the script has loaded or not.

                // on load of the script, enable logging to console.

                script.onload = function () {

                    global.core.debugMode.enabled(console.log, 'verbose');

                };

                script.onreadystatechange = function () {

                    if (this.readyState === 'complete' || this.readyState ===

                        'loaded') {

                        global.core.debugMode.enabled(console.log, 'verbose');

                    }

                };

                

                // Append the script to the head of this page.

                document.getElementsByTagName('head')[0].appendChild(script);

            }

        }

    }, false);

    

}());







/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,

  eqeqeq: true, plusplus: true, bitwise: true, regexp: true, immed: true */



/*global Array: false, FusionCharts, RegExp: false, window: false

    FusionChartsDataFormats: true */



/*members FusionCharts, XMLURL, addEventListener, appendChild, apply,

    args, call, config, configure, containerElement, containerElementId,

    core, createElement, currentRendererName, dataFormat, extend,

    firstChild, getAttribute, getElementById, getElementsByTagName,

    getExternalInterfaceMethods, getRenderer, getRendererPolicy,

    hasChildNodes, id, init, initialized, insertMode, items, length,

    options, parsePolicies, policies, prototype, raiseError, raiseEvent,

    ref, register, removeChild, render, renderer, resize, sender,

    setAttribute, setCurrentRenderer, setDefault, slice, split, success,

    toLowerCase, toString, undefined, update, __state, rendering

*/



/**

 * -----------------------------------------------------------------------------

 * Renderer Abstraction Framework

 * This module allows developers to abstract the entire rendering engine. This

 * helps in multiple implementations of FusionCharts in various technologies

 * such as flash, HTML5, etc.

 * -----------------------------------------------------------------------------

 */

(function () {



    // Register the module with FusionCharts.

    var global = FusionCharts(['private', 'RendererManager']);

    // Check whether the module has been already registered. If true, then

    // do not bother to re-register.

    if (global === undefined) {

        return;

    }



    // Allow FusionCharts to accept parameter to specify where to render the

    // chart.

    global.policies.options.containerElementId = ['renderAt', undefined];

    global.policies.options.renderer = ['renderer', undefined];



    // Collection of renderers.

    var notDefined = function () {

        global.raiseError(this, '25081845', 'run', '::RendererManager',

            new Error('No active renderer'));

        return;

    };

    var renderers = {

        'undefined': {

            render: notDefined, 

            update: notDefined,

            resize: notDefined,

            config: notDefined,

            policies: {}

        }

    }, store = {}; // store which chart has what renderer



    // API to add renderer and also to set/get the current renderer.

    global.renderer = {

        register: function (name, obj) {

            // Validate parameters

            if (!name || typeof name.toString !== 'function') {

                throw "#03091436 ~renderer.register() Invalid value for renderer name.";

            }



            // Desensitize character case for renderer name

            name = name.toString().toLowerCase();



            // Prevent addition of duplicate renderer

            if (renderers[name] !== undefined) {

                global.raiseError(global.core, '03091438', 'param', '::RendererManager>register',

                    'Duplicate renderer name specified in "name"');

                return false;

            }



            // Add renderer to the collection of renderers.

            renderers[name] = obj;

            // Return true when a new renderer is successfully added.

            return true;

        },



        // Set the current renderer

        setDefault: function (name) {

            // Validate parameters

            if (!name || typeof name.toString !== 'function') {

                global.raiseError(global.core, '25081731', 'param', '::RendererManager>setDefault',

                    'Invalid renderer name specified in "name"');

                return false;

            }

            

            // Validate the renderer name and see whether the parameter refers to a

            // valid renderer.

            // ALSO: Desensitize character case for renderer name.

            if (renderers[name = name.toString().toLowerCase()] === undefined) {

                global.raiseError(global.core, '25081733', 'range', '::RendererManager>setDefault',

                    'The specified renderer does not exist.');

                return false;

            }



            // Set reference to the current renderer.

            global.policies.options.renderer = ['renderer', name];

            return true;

        },



        getRenderer: function (name) {

            return renderers[name];

        },



        getRendererPolicy: function (name) {

            var policies = renderers[name].policies;

            return typeof policies === 'object' ? policies : {};

        },



        currentRendererName: function () {

            return global.policies.options.renderer[1];

        },



        update: function (obj) {

            store[obj.id].update.apply(obj,

                Array.prototype.slice.call(arguments, 1));

        },



        render: function (obj) {

            store[obj.id].render.apply(obj,

                Array.prototype.slice.call(arguments, 1));

        },



        resize: function (obj) {

            store[obj.id].resize.apply(obj,

                Array.prototype.slice.call(arguments, 1));

        },



        config: function (obj) {

            store[obj.id].config.apply(obj,

                Array.prototype.slice.call(arguments, 1));

        }

    };





    // This function allows users to make a generic call to external interface

    // of the chart via the FusionCharts object

    var eiCall = function (method) {

        return function () {

            // Verify whether the chart is valid object and then proceed.

            if (this.ref === undefined  || this.ref === null  ||

                typeof this.ref[method] !== 'function') {

                // Raise error event to notify that a method on the renderer was

                // invoked while the renderer does not have such a method.

                global.raiseError(this, '25081617', 'run', '~' + method + '()',

                    'ExternalInterface call failed. Check whether chart has been rendered.');

                return undefined;

            }

            

            return this.ref[method].apply(this.ref, arguments);

        };

    };



    // Constructor to add renderer functions

    global.addEventListener('BeforeInitialize', function (event) {

        // Reference to event sender.

        var obj = event.sender;

        

        // Check if construction has the default renderer name saved.

        if (typeof obj.options.renderer === 'string' &&

            renderers[obj.options.renderer.toLowerCase()] === undefined) {

            obj.options.renderer = global.policies.options.renderer[1];

        }

        // Desensitize the case of the parameter.

        obj.options.renderer = obj.options.renderer.toLowerCase();



        // Keep a reference

        store[obj.id] = renderers[obj.options.renderer];



        // Check whether this particular renderer has been rendered.

        if (store[obj.id].initialized !== true &&

            typeof store[obj.id].init === 'function') {

            // Call the 'init' function on the renderer and set a flag.

            store[obj.id].init();

            store[obj.id].initialized = true;

        }



        // Parse construction policies specific to this renderer.

        global.parsePolicies(obj, store[obj.id].policies || {}, obj.args);



        // Copy the prototype of the renderer specified in constructor to the

        // main object.

        for (var prop in store[obj.id].prototype) {

            obj[prop] = store[obj.id].prototype[prop];

        }



    });



    global.addEventListener('Loaded', function (e) {



        // Store a reference to the chart swf HTML Node.

        var obj = e.sender, chartObj = e.sender.ref;



        // Clear the flag that keeps a track whether the chart is presently

        // in a 'rendering' state

        if (obj instanceof global.core) {

            delete obj.__state.rendering;

        }



        // Validate whether the chart swf node exists and that it has

        // the prerequisite externalInterface functions.

        if (chartObj === undefined || chartObj === null || typeof

            chartObj.getExternalInterfaceMethods !== 'function') {

            return;

        }



        // The externalInterfaceMethods names are parsed from CSV to

        // Array.

        var eiItems = chartObj.getExternalInterfaceMethods().split(','),

            i;



        // We iterate through all the externalInterface method names and

        // create an extensible API object that is added to main

        // FusionCharts object as reference.

        for (i = 0; i < eiItems.length; i += 1) {

            // Copy method from renderer only when a local method does not exist

            if (obj[eiItems[i]] === undefined) {

                obj[eiItems[i]] = eiCall(eiItems[i]);

            }

        }

    });





// ============================================================================



    // Function that checks duplicate.

    var isDuplicateId = function (lookupId, container) {

        // Get the lookup element from the ID sent via parameter.

        var lookupElement = document.getElementById(lookupId),

            // Get the ID of the container element.

            containerId = container.getAttribute('id');



        // Check whether the element exists or not. If it does not exist, it

        // implies that there cannot be any duplicate.

        if (lookupElement === null) {

            return false;

        }



        // In case chart's Id and container's Id is same then is duplicate.

        if (lookupId === containerId) {

            return true;

        }



        // Check whether the lookup element returned before is actually

        // inside container or not.

        var children = container.getElementsByTagName('*');

        for (var i = 0; i < children.length; i += 1) {

            if (children[i] === lookupElement) {

                return false;

            }

        }

        // If the lookupElement is outside/before the container, it implies

        // that it is a duplicate.

        return true;

    };



    // Define a function that saves the reference to the embedded object

    // after it has been rendered.

    var updatePostRender = function (status) {

        // Check whether the render was successful.

        if (status.success === false) {

            global.raiseError(global.core.items[status.id], '25081850', 'run', '::RendererManager',

                new Error('There was an error rendering the chart. ' +

                    'Enable FusionCharts JS debugMode for more information.'));

        }

        

        // Lookup the FusionCharts object within its "items" repository.

        global.core.items[status.id].ref = status.ref;

        

        // If the ref has been created, create a reverse reference.

        if (status.ref) {

            status.ref.FusionCharts = global.core.items[status.id];

        }



        // Raise event that this chart has a DOM element

        global.raiseEvent('internal.DOMElementCreated', status,

            global.core.items[status.id]);



    };



    global.extend({

        render: function (containerElement) {



            // Check IE-Safe variable name collision within Global Scope

            if (window[this.id] !== undefined) {

                global.raiseError(this, '25081843', 'comp', '.render',

                    new Error('#25081843:IECompatibility() Chart ' +

                    'Id is same as a JavaScript variable name. Variable naming ' +

                    'error. Please use unique name for chart JS variable, ' +

                    'chart-id and container id.'));

            }



            // Create a blank element inside to mimic alternativecontent

            var alt = document.createElement('span');



            // Procure containerElement from internal object options that has

            // been passed via parameters.

            if (containerElement === undefined) {

                containerElement = this.options.containerElementId;

            }



            // In case user sends the element id, we get the object from it

            if (typeof containerElement === 'string') {

                containerElement = document.getElementById(containerElement);

            }

            if (containerElement === undefined || containerElement === null) {

                global.raiseError(this, '03091456', 'run', '.render()',

                    new Error("Unable to find the container DOM element."));

                return this;

            }



            // Check duplicate rendering with same id

            if (isDuplicateId(this.id, containerElement)) {

                global.raiseError(this, '05102109', 'run', '.render()',

                    new Error("A duplicate object already exists with the specific Id: " + this.id));

                return this;

            }



            // Set the attribute of this element that will be replaced by

            // swfobject

            alt.setAttribute('id', this.id);



            // Clear the contents of the containerElement and subsequently

            // append the new alt content.

            if (this.options.insertMode === 'replace') {

                while (containerElement.hasChildNodes()) {

                    containerElement.removeChild(containerElement.firstChild);

                }

            }

            containerElement.appendChild(alt);



            // Update the present container details in object.

            this.options.containerElement = containerElement;

            this.options.containerElementId = containerElement.id;



            // Set state that the chart is rendering

            this.__state.rendering = true;



            // Call the current renderer.

            global.renderer.render(this, containerElement, updatePostRender);



            // Return the fusioncharts object for chainability

            return this;

        },

        

        configure: function (key, value) {

            global.renderer.config(this, (typeof key === 'object') ? key : (function () {

                var items = {};

                items[key] = value;

                return items;

            }()));

        }

    }, true);



    global.extend({

        setCurrentRenderer: global.renderer.setDefault,



        /**

         * Render FusionCharts directly using the simplest one-line argument

         * parameter.

         * This function directly renders FusionCharts into the container

         * specified in arguments.

         */

        render: function () {



            // The order in which to parse the linear parameters.

            var argsT = ['swfUrl', 'id', 'width', 'height', 'renderAt',

                'dataSource', 'dataFormat'], params = {}, i;



            // If a FusionCharts object is sent to it, it calls render method of

            // it.

            if (arguments[0] instanceof global.core) {

                arguments[0].render();

                return arguments[0];

            }



            // Iterate through the linear parameters using the argument template

            // array defined above and create a parameter object out of it.

            for (i = 0; (i < arguments.length && i < argsT.length); i += 1) {

                params[argsT[i]] = arguments[i];

            }



            // Incorporate the trailing object parameter as object-style

            // parameter input overrides.

            if (typeof arguments[arguments.length - 1] === 'object') {

                delete params[argsT[i - 1]];

                global.extend(params, arguments[arguments.length - 1]);

            }



            // Pre-specify the 'xmlurl' format

            if (params.dataFormat === undefined) {

                params.dataFormat = FusionChartsDataFormats.XMLURL;

            }



            // Render a new FusionCharts out of the parameters and return the

            // object.

            return new global.core(params).render();

            

        }

    }, false);

}());







/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,
  eqeqeq: true, plusplus: true, bitwise: true, regexp: true, immed: true */

/*global window: false, Array, FusionCharts, Error: false */

/*members ActiveXObject, FC_DataLoadError, FusionChartsDataFormats,
    XMLHttpRequest, __state, abort, addDataHandler, addEventListener, ajax,
    apply, call, cancelDataLoad, cancelDataLoadRequest, cancelDataUpdate,
    core, data, dataError, dataFormat, dataSource, decode, encode, error,
    extend, format, get, getChartData, httpStatus, id, isActive, location,
    onreadystatechange, open, options, overrideMimeType, policies, protocol,
    prototype, push, raiseError, raiseEvent, raiseWarning, readyState,
    renderer, rendering, responseText, send, sender, setChartData,
    setChartDataUrl, setRequestHeader, slice, source, status, test,
    toLowerCase, toString, transcodeData, update, updatePending, url, x,
    xmlHttpRequestObject
*/

/**
 * -----------------------------------------------------------------------------
 * Data-Handler Abstraction Framework
 * This allows developers to dynamically integrate a data transcoder so that
 * FusionCharts core can seamlessly work with multiple formats for data
 * provisioning.
 * -----------------------------------------------------------------------------
 */

(function () {

    // Register the module with FusionCharts.
    var global = FusionCharts(['private', 'DataHandlerManager']);
    // Check whether the module has been already registered. If true, then
    // do not bother to re-register.
    if (global === undefined) {
        return;
    }

    // Collection of Data Formats
    window.FusionChartsDataFormats = {};

    /**
     * Global AJAX framework to manage AJAX data requests for data transactions.
     * @id global.ajax
     * @type object
     */
    global.ajax = (function () {

        /**
         * Function that internally manages AJAX error events. When called, it
         * passes on error details to the user-assigned ajax.error function.
         *
         * @param x {XMLHttpRequest}
         * @param e {Error}
         * @param args {arguments}
         *
         * @type void
         */
        var error = function (ajaxApi, x, e, args) {
            if (typeof ajaxApi.error === 'function') {
                // Replace the 'callBack' function reference with xmlHttpRequest
                // object as the error event need not know about the callback.
                args[1] = x;
                // As the arguments (args) may not be an array, we pass it to
                // array object prototype before pushing in the arguments.
                Array.prototype.push.call(args, e);
                // Call the public error method with arguments in the same order
                // as what was passed to the 'get' method.
                ajaxApi.error.apply(ajaxApi, args);
            }
        };

        var api = {
            x: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ? function () {
                return new window.XMLHttpRequest();
            } : function () {
                try {
                    return new window.ActiveXObject("Microsoft.XMLHTTP");
                }
                catch (e) {
                    throw "Charts cannot render due to lack of AJAX support. Use setDataURL for fallback";
                }
            },

            get: function (u, f) {

                var x = api.x(), args = arguments;
                x.onreadystatechange = function () {
                    try {
                        if (x.readyState === 4) {
                            if (x.status === 200 || x.status === 0) {
                                f(x.responseText, x);
                            }
                            else {
                                error(api, x, new Error('XMLHttpRequest Error'), args);
                            }
                        }
                    }
                    catch (e) {
                        error(api, x, e, args);
                    }
                };

                try {
                    if (x.overrideMimeType) {
                        x.overrideMimeType('text/plain');
                    }
                    x.open('GET', u, true);
                    x.setRequestHeader('If-Modified-Since', 'Sat, 29 Oct 1994 19:43:31 GMT');
                    x.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
                    x.setRequestHeader('Accept', 'text/plain, */*');
                    x.send(null);
                }
                catch (e) {
                    error(api, x, e, args);
                }

                // Return the xmlhttp object
                return x;
            }
        };

        return api;

    }());

    // Function to manage ajax error events
    global.ajax.error = function (url, x, method, obj, e) {

        // Compile argument for event.
        var eventArgs = {
            source: method,
            url: url,
            xmlHttpRequestObject: x,
            error: e,
            httpStatus: (x && x.status) ? x.status : -1
        };
	
        // Raise data load error message.
        global.raiseEvent('DataLoadError', eventArgs, obj);

        // Call legacy event handler.
        if (typeof window.FC_DataLoadError === 'function') {
            window.FC_DataLoadError(obj.id, eventArgs);
        }
    };

    // Store all data handlers here in a collection and also store all 'data' of
    // every chart in an object.
    /**
     * @var {object} cache stores the parsed JSON data as a cache location, so
     * that multiple calls to decode JSON does not involve redundant conversion.
     */
    var handlers = {}, dataStore = {}, xStore = {}, cache = {}, isUrl =  /url$/i;


    // Function to abort ajax request from httpRequest cache
    var abortAjaxOf = function (id) {
        // Clear any previous xmlHttpRequest.
        if (xStore[id] && typeof xStore[id].abort === 'function' &&
            xStore[id].readyState && xStore[id].readyState !== 0) {
            xStore[id].abort();
            return true;
        }
        return false;
    };
    
    // Allow data-related parameters to be passed in constructor
    global.policies.options.dataSource = ['dataSource', undefined];
    global.policies.options.dataFormat = ['dataFormat', undefined];

    // Expose Data handler and related management API.
    global.addDataHandler = function (name, obj) {
        if (typeof name !== 'string' || handlers[name.toLowerCase()] !== undefined) {
            global.raiseError(global.core, '03091606', 'param',
                '::DataManager.addDataHandler', new Error('Invalid Data Handler Name'));
            return;
        }
        var api = {}, lcaseName = name.toLowerCase();

        // Add handler to collection
        handlers[lcaseName] = obj;

        // Create Handler Direct Access API. This adds common fuctions for the
        // handler.
        api['set' + name + 'Url'] = function (url) {
            return this.setChartDataUrl(url, name);
        };

        api['set' + name + 'Data'] = function (data) {
            return this.setChartData(data, name);
        };

        api['get' + name + 'Data'] = function () {
            return this.getChartData(name);
        };

        // Add data formats to global formats collection
        window.FusionChartsDataFormats[name] = lcaseName;
        window.FusionChartsDataFormats[name + 'URL'] = lcaseName + 'URL';

        // Extend FusionCharts objects
        global.extend(api, true);
    };

    // Add constructor to initialize datastore or to clear any garbage.
    global.addEventListener('BeforeInitialize', function (event) {

        // Get short reference to the event sender.
        var obj = event.sender;

        // Clear the dataStore, cache and xStore when new chart is created.
        dataStore[obj.id] = '';
        cache[obj.id] = {};


        // Set intitial data if present
        if (obj.options.dataSource !== undefined &&
            typeof obj.options.dataFormat === 'string') {
            obj.setChartData(obj.options.dataSource, obj.options.dataFormat);
        }
    });

    // Add method to make sure to delete all fusioncharts objects when
    // dispose method is invoked
    global.addEventListener('BeforeDispose', function (e) {
        delete dataStore[e.sender.id];
        delete cache[e.sender.id];
        abortAjaxOf(e.sender.id);
    });

    // Add getter and setter to FusionCharts Objects
    global.extend({
        setChartDataUrl: function (url, format, silent) {
            if (format === undefined || format === null || typeof format.toString !== 'function') {
                global.raiseError(global.core, '03091609', 'param',
                    '.setChartDataUrl', new Error('Invalid Data Format'));
                return;
            }

            // Desensitize case of parameter.
            format = format.toString().toLowerCase();

            /**
             * @var {Boolean} cancelDLRFlag is to allow users to flag that 
             * data-load request has to be cancelled.
             */
            var baseFormat, obj = this, cancelDLRFlag = false;

            // Check whether the data-format has "url" at the end of it.
            // We compute the base format and update the format accordingly so
            // that format always ends with 'url' and the baseFormat contains real
            // format name.
            if (isUrl.test(format)) {
                baseFormat = format.slice(0, -3);
            }
            else {
                baseFormat = format;
                format = format + 'url';
            }
            
            // Raise event to notify xmlhttprequest transaction start.
            global.raiseEvent('DataLoadRequested', {
                source: 'XmlHttpRequest',
                url: url,
                dataFormat: baseFormat,
                cancelDataLoadRequest: function () {
                    cancelDLRFlag = true;
                    this.cancelDataLoadRequest = function () {
                        return false;
                    };
                    return true;
                }
            }, obj);

            // Check if user cancelled dataload request.
            if (cancelDLRFlag === true) {
                global.raiseEvent('DataLoadRequestCancelled', {
                    source: 'XmlHttpRequest',
                    url: url,
                    dataFormat: baseFormat
                }, obj);

                // Exit from this function
                return;
            }

            // Update reference to data-source.
            this.options.dataSource = url;

            // Initiate XmlHttpRequest.
            xStore[this.id] = global.ajax.get(decodeURIComponent(url), function (responseText, x) {
                // Allow cancellation of data loaing
                var cancelDLFlag = false;

                // Raise pre data-load event
                global.raiseEvent('DataLoadRequestCompleted', {
                    source: 'XmlHttpRequest',
                    url: url,
                    data: responseText,
                    dataFormat: baseFormat,
                    cancelDataLoad: function () {
                        cancelDLFlag = true;
                        this.cancelDataLoad = function () {
                            return false;
                        };
                        return true;
                    },
                    xmlHttpRequestObject: x
                }, obj);

                // Update the chart's dataStore with data received
                // from url.
                if (cancelDLFlag !== true) {
                    // Set the chart's data received from url.
                    obj.setChartData(responseText, baseFormat, silent);
                }
                else {
                    // Raise post data load event .
                    global.raiseEvent('DataLoadCancelled', {
                        source: 'XmlHttpRequest',
                        url: url,
                        dataFormat: baseFormat,
                        xmlHttpRequestObject: x
                    }, obj);
                }

                // Delete the xmlhttp object.
                delete xStore[this.id];

            }, 'XmlHttpRequest', this);

        },

        setChartData: function (data, format, silent) {
            // In case format is not a string, we raise an error
            if (format === undefined || format === null || typeof format.toString !== 'function') {
                global.raiseError(global.core, '03091610', 'param',
                    '.setChartData', new Error('Invalid Data Format'));
            }
            // Desensitize case of parameter.
            format = format.toString().toLowerCase();

            // Thebase format is set by truncating fetching method from the
            // formatg-string and then stored in 'baseFormat' variable.
            var baseFormat;

            // Check whether the data-format has "url" at the end of it. If true,
            // then we call the setChartDataUrl method and that in turn calls this
            // method as callback (marked as _recursed.)
            if (isUrl.test(format)) {
                this.setChartDataUrl(data, format, silent);
                return;
            }
            // When there is no trailing "url" in data-format, we assume that
            // the format provided is baseFormat itself.
            else {
                // Update the dataSource here only when we know that this call
                // was not recursed for dataurl purpose
                this.options.dataSource = data;
                baseFormat = format;
            }
            // Update chart's internal data-format options
            this.options.dataFormat = format;

            // Fetch the data-handler function from the dataHandler collection.
            var handler = handlers[baseFormat], parseResult, eventArgs,
                cancelDUFlag = false;

            // If the handler has been successfully fetched, execute it.
            if (typeof handler === 'undefined') {
                global.raiseError(global.core, '03091611', 'param',
                    '.setChartData', new Error('Data Format not recognized'));
                return;
            }

            // Execute the parser and fetch the parsing result.
            parseResult = handler.encode(data, this);
            // Updated the result so that it can be passed as event argument.
            parseResult.format = baseFormat;

            // Create argument for events
            eventArgs = {
                dataFormat: baseFormat,
                dataSource: data,
                dataError: parseResult.error,
                data: parseResult.data,
                cancelDataUpdate: function () {
                    cancelDUFlag = true;
                    this.cancelDataUpdate = function () {
                        return false;
                    };
                    return true;
                }
            };

            global.raiseEvent('BeforeDataUpdate', eventArgs, this);
            delete eventArgs.cancelDataUpdate; // Remove cancellation fn.

            // Update event only if it is not marked to be cancelled by user.
            if (cancelDUFlag === true) {
                global.raiseEvent('DataUpdateCancelled', eventArgs, this);
                return;
            }

            // Save data within dataStore
            dataStore[this.id] = (parseResult.data = eventArgs.data) || '';
            // Clear cache
            cache[this.id] = {};
            
            // Raise data updation event if it is not marked as silent data
            // updating.
            if (silent !== true) {
                // stall this update if this is stuck in between a render and loading
                if (this.options.safeMode === true &&
                    this.__state.rendering === true && !this.isActive()) {
                    this.__state.updatePending = parseResult;
                    global.raiseWarning(this, '23091255', 'run', '::DataHandler~update',
                    'Renderer update was postponed due to async loading.');
                }
                else {
                    delete this.__state.updatePending;
                    global.renderer.update(this, parseResult);
                }
            }
            
            // DevNote: This event must not be raised asynchronously in order
            // to maintain integrity and timing of related codes.
            global.raiseEvent('DataUpdated', eventArgs, this);
        },

        getChartData: function (format, advanced) {

            // Variable to store a reference to the data-handler.
            var handler, parseResult;
            // Desensitize case of parameter and fetch the data-handler
            // function from the dataHandler collection within the validation
            // check itself.

            if (format === undefined || typeof format.toString !== 'function' ||
                (handler = handlers[format = format.toString().toLowerCase()]) === undefined) {
                global.raiseError(this, '25081543', 'param', '~getChartData()',
                    new Error('Unrecognized data-format specified in "format"'));
                return undefined;
            }

            // Check presence of cached data or call the decoder routine of
            // the data-handler and return the decoded data.
            parseResult = (typeof cache[this.id][format] === 'object') ?
                cache[this.id][format] :
                cache[this.id][format] = handler.decode(dataStore[this.id], this);

            // Return the eminent data (in advanced mode if needed.
            return Boolean(advanced) === true ? parseResult : parseResult.data;
        }
    }, true);

    global.extend({
        transcodeData: function (data, from, to, advanced) {
            
            // Validate parameters.
            if (!from || typeof from.toString !== 'function' || !to ||
                typeof to.toString !== 'function' || 
                handlers[(to = to.toString().toLowerCase())] === undefined ||
                handlers[(from = from.toString().toLowerCase())] === undefined) {
                global.raiseError(this, '14090217', 'param', 'transcodeData()',
                    new Error('Unrecognized data-format specified during transcoding.'));
                return undefined;
            }

            // Chain the decoder and encoder.
            var l1 = handlers[from].encode(data, this), 
                l2 = handlers[to].decode(l1.data, this);

            // Carry the error.
            if (!(l2.error instanceof Error)) {
                l2.error = l1.error;
            }
            return advanced ? l2 : l2.data;
        }
    }, false);

    // Attach an event handler to clear the data cache when chart is disposed.
    global.core.addEventListener('Disposed', function (e) {
        delete cache[e.sender.id];
    });

    // Check for pending data updates
    global.core.addEventListener('Loaded', function (e) {
        var obj = e.sender;
        if (obj instanceof global.core && obj.__state.updatePending !== undefined) {
            global.renderer.update(obj, obj.__state.updatePending);
            delete obj.__state.updatePending;
        }
    });


}());


/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,
    eqeqeq: true, plusplus: true, bitwise: true, immed: true */

/*global window: false, Array: false, FusionCharts: false,
    FusionChartsEvents: false, FusionChartsDataFormats: false*/

/*members XML, XMLURL, addEventListener, animate, apply, args,
    attributes, chartType, clone, constructor, core, dispose, exportChart,
    extend, getAttribute, getChartFromId, getDataAsCSV, getElementById,
    getElementsByTagName, getObjectById, getRendererPolicy, getXML,
    hasRendered, height, id, indexOf, isActive, items, lastIndexOf, length,
    link, options, params, policies, print, raiseError, raiseEvent, ref,
    renderer, replace, resize, resizeTo, scriptBaseUri, sender,
    setChartData, setDataURL, setDataXML, signature, split, src, stallLoad,
    substring, success, swfobject, test, toLowerCase, toString, vars, vled,
    width
*/

/**
 * -----------------------------------------------------------------------------
 * Generic Runtime Module
 * -----------------------------------------------------------------------------
 */
(function () {

    // Register the module with FusionCharts.
    var global = FusionCharts(['private', 'GenericRuntime']);
    // Check whether the module has been already registered. If true, then
    // do not bother to re-register.
    if (global === undefined) {
        return;
    }

    // Set the FusionCharts filename possibilities as regular expression.
    var SCRIPT_NAME_REGEX = /(fusioncharts\.js|fusioncharts\.debug\.js|fusioncharts\.core\.js|fusioncharts\.min\.js|fusioncharts\.packed\.js)(\?.*)?$/i;

    // Collection of chart alias that are not same as swf filename
    var alias = {
        vled: 'realtimeverticalled'
    };

    // Get the script base uri.
    global.core.options.scriptBaseUri = (function () {
        // Get a collection of all script nodes.
        var scripts = document.getElementsByTagName('script'),
            l = scripts.length, scriptBaseUri = '', i;

        // Iterate through the script node collection and match whether its
        // 'src' attribute contains fusioncharts file name.
        for (i = 0; i < l; i += 1) {
            // In case the script name regex matches with an src, we use that
            // src to retrieve the base uri.
            if (SCRIPT_NAME_REGEX.test(scripts[i].getAttribute('src'))) {
                // To retrieve the base path of the src, we simply do a string
                // split withg the fusioncharts filename and get the first item
                // of script base uri.
                scriptBaseUri = scripts[i].getAttribute('src').split(SCRIPT_NAME_REGEX)[0];
                break;
            }
        }

        return scriptBaseUri;

    }());

    // Deconstruct policies.
    // Update the arguments with latest copy of all variables by
    // reverse engineering the policies.
    var deconstructPolicySet = function (policies, options, obj) {
        for (var policy in policies) {
            // Set just the policy object in case of single-level policy.
            if (policies[policy] instanceof Array) {
                options[policies[policy][0]] = obj[policy];
                continue;
            }
            // Copy the source of multi-level policies
            for (var prop in policies[policy]) {
                options[policies[policy][prop][0]] = obj[policy][prop];
            }
        }
    }, lengthCleanupRegex = /[^\%\d]*$/g, signatureMatchRegex = /^FusionCharts/;

    global.extend({
        // Add default object management prototype method to raise deletion
        // event.
        dispose: function () {
            // The event must be async in order to prevent integrity.
            global.raiseEvent('BeforeDispose', {}, this);
            // Delete the reference of the item
            delete global.core.items[this.id];
            // Raise a post-disposal event
            global.raiseEvent('Disposed', {}, this);
        },

        clone: function (params, noCreate) {

            // Create a copy of arguments of this object.
            var options = global.extend({}, this.args);

            // Recreate construction parameters by reverse calculating the global
            // policies.
            deconstructPolicySet(global.policies, options, this);
            // Also deconstruct the rendere specific policies.
            deconstructPolicySet(global.renderer.getRendererPolicy(this.options.renderer),
                options, this);

            // Remove any specific parameters that if cloned will create issues.
            delete options.id;
            delete options.animate;
            delete options.stallLoad;

            // Override any of the options by parameters sent by user
            if (typeof params === 'object') {
                global.extend(options, params);
            }

            // Create new FusionCharts object from the computed options
            return noCreate ? options : new global.core(options);

        },
        
        /**
         * Legacy function that simply calls setDataXML on JS object.
         * @id FusionCharts.setDataXML
         *
         * @param {string} xml The data as string in FusionCharts compatible XML
         * format.
         *
         * @type void
         * @deprecated
         */
        setDataXML: function (xml) {
            // Check whether the XML as parameter can be converted to
            // string or not and then send data to chart.
            if (xml === undefined || xml === null ||
                typeof xml.toString !== 'function') {
                // Notify using error event that invalid data was provided as xml.
                global.raiseError(this, '25081627', 'param', '~setDataXML',
                    'Invalid data type for parameter "xml"');
                return;
            }

            // We check whether the renderer has setDataXML function, we set it.
            if (this.ref === undefined || this.ref === null ||
                typeof this.ref.setDataXML !== 'function') {
                this.setChartData(xml.toString(), FusionChartsDataFormats.XML);
            }
            else {
                // When direct XML updated API is available we use it to directly
                // do remote update of XML.
                this.ref.setDataXML(xml.toString());
            }

        },

        /**
         * @id FusionCharts.setDataURL
         *
         * @param {string} url 
         *
         * @type void
         * @deprecated
         */
        setDataURL: function (url) {
            // Check whether the URL as parameter can be converted to
            // string or not.
            if (url === undefined || url === null ||
                typeof url.toString !== 'function') {
                // Notify using error event that invalid data was provided as xml.
                global.raiseError(this, '25081724', 'param', '~setDataURL',
                    'Invalid data type for parameter "url"');
                return;
            }

            // We check whether the renderer has setDataURL function, we set it.
            if (this.ref === undefined || this.ref === null ||
                typeof this.ref.setDataURL !== 'function') {
                // For flash renderer, we set the flashVars, so that it is picked
                // up when chart renders.
                this.setChartData(url.toString(), FusionChartsDataFormats.XMLURL);
            }
            else {
                // When direct XML updated API is available we use it to directly
                // do remote update of XML.
                this.ref.setDataURL(url.toString());
            }
        },

        isActive: function () {
            if (!this.ref || document.getElementById(this.id) !==
                this.ref || typeof this.ref.signature !== 'function') {
                return false;
            }
            
            try {
                return signatureMatchRegex.test(this.ref.signature());
            }
            catch (e) {
                return false;
            }
        },

        resizeTo: function (w, h, noUpdate) {
            var dimension = {
                width: w,
                height: h
            };

            if (typeof arguments[0] === 'object') {
                dimension.width = arguments[0].width;
                dimension.height = arguments[0].height;
                noUpdate = h;
            }

            if (dimension.width && typeof dimension.width.toString === 'function') {
                this.width = dimension.width.toString().replace(lengthCleanupRegex, '');
            }
            if (dimension.height && typeof dimension.height.toString === 'function') {
                this.height = dimension.height.toString().replace(lengthCleanupRegex, '');
            }

            if (noUpdate !== true) {
                global.renderer.resize(this, dimension);
            }
        },
        
        // Add function to get chart type name from SWF
        chartType: function () {
            var url = this.src.substring(this.src.indexOf('.swf'), 0),
                file = url.substring(url.lastIndexOf('/') + 1).toLowerCase();
            return alias[file] === undefined ? file : alias[file];
        }

    }, true);

    // Globally expose getChartFromId method.
    window.getChartFromId = function (id) {
        return global.core.items[id] instanceof global.core ?
            global.core.items[id].ref : global.swfobject.getObjectById(id);
    };


    // This function allows users to make a generic call from renderer
    // of the chart to main FusionCharts object.
    var jsCall = function (obj, prop) {
        // Check whether me
        if (typeof obj[prop] === 'function') {
            return function () {
                return obj[prop].apply(obj, arguments);
            };
        }
        return obj[prop];
    };

    /**
     * Extend FusionCharts capabilities to swf HTMLNode object
     */
    global.addEventListener('internal.DOMElementCreated', function (event, args) {
        // Check whether the object was added to DOM or not.
        if (args.ref === undefined || args.success !== true) {
            return;
        }

        // List the properties that are not to be extended.
        var ignore = {
            options: true,
            vars: true,
            attributes: true,
            params: true,
            src: true,
            ref: true,
            constructor: true,
            setDataXML: true,
            setDataURL: true,
            hasRendered: true,
            getXML: true,
            getDataAsCSV: true,
            print: true,
            exportChart: true,
            signature: true,
            link: true
        };

        // Iterate through the FusionCharts object and add its variables to the
        // HTMLNode object.
        for (var prop in event.sender) {
            // Discontinue adding this object in case the property is marked to
            // be ignored.
            if (ignore[prop] === true || args.ref[prop] !== undefined) {
                continue;
            }
            try {
                args.ref[prop] = jsCall(event.sender, prop);
            }
            // Suppress error while updating DOM events.
            catch (e) { }
        }
    });

}());



/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,
  eqeqeq: true, plusplus: true, bitwise: true, regexp: true, immed: true */

/*global Array: false, FusionCharts, RegExp: false, FusionChartsDataFormats: false */

/*members JSON, animation, chart, extend, getChartAttribute,
    getChartData, graph, length, raiseError, setChartAttribute,
    setChartData, toLowerCase, toString
*/

/**
 * -----------------------------------------------------------------------------
 * Dynamic Chart Attributes Module
 * -----------------------------------------------------------------------------
 * This module contains codes required to get and set chart attributes from a
 * FusionCharts object using simple getter and setter functions. These method
 * completely bypasses the data transfer from the SWF and computes chart
 * attributes based on the last set data.
 */
(function () {

    // Register the module with FusionCharts.
    var global = FusionCharts(['private', 'DynamicChartAttributes']);
    // Check whether the module has been already registered. If true, then
    // do not bother to re-register.
    if (global === undefined) {
        return;
    }

    global.extend({
        /**
         * Updates a FusionCharts object's XML root's attribute with the new
         * attribute-value pair. In case the attribute does not exist, it adds
         * it.
         *
         * @param attributes {object} The attributes to be updated.
         *
         * @type string
         * @return Updated FusionCharts DataXML with the new attribute added or
         * updated
         */
        setChartAttribute: function (attributes) {

            // In case attribute is sent as separate arguments, combine them
            // to one object.
            if (arguments.length > 1 && typeof attributes === 'string') {
                var temp = arguments[0];
                attributes = {};
                attributes[temp] = arguments[1];
            }
            // In case user sends invalid parameters for attributes.
            else if (attributes === null || typeof attributes !== 'object') {
                return;
            }

            // Get chart attributes.
            var i = 0, json = this.getChartData(FusionChartsDataFormats.JSON), prop,
                attList = json.chart || json.graph || {};

            // Iterate through attributes and update them.
            for (prop in attributes) {
                i += 1;
                attList[prop.toLowerCase()] = attributes[prop];
            }
            // Update chart's XML.
            if (i > 0) {
                // In case animation is not specified, then turn it off.
                if (typeof attList.animation === 'undefined') {
                    attList.animation = '0';
                }
                this.setChartData(json, FusionChartsDataFormats.JSON);
            }
        },

        /**
         * Returns the value of a specific chart attribute.
         *
         * @param attribute {string} The attributes to be fetched.
         *
         * @type string
         * @return The value of the attribute.
         */
        getChartAttribute: function (attribute) {

            // Get chart attributes.
            var attList = (attList = 
                this.getChartData(FusionChartsDataFormats.JSON)).chart || attList.graph;
            
            // In case no argument is passed, we return the entire set of
            // chart attributes object.
            if (arguments.length === 0 || attribute === undefined || attList === undefined) {
                return attList;
            }

            // Create a variable that will store reference to the parameter that
            // contains attributes. This helps in case user sends one attribute
            // as string, we covert it to an array witj one element.
            var value, i;

            // Convert single attribute to array with one element or directly
            // send the value as return.
            if (typeof attribute === 'string') {
                value = attList[attribute.toString().toLowerCase()];
            }

            // In case user sends an array of attributes, we compile an object
            // for the same and return.
            else if (attribute instanceof Array) {
                value = {};
                for (i = 0; i < attribute.length; i += 1) {
                    value[attribute[i]] =
                        attList[attribute[i].toString().toLowerCase()];
                }
            }

            // If all above conditions fail, there must be some issue with the
            // parameters.
            else {
                global.raiseError(this, '25081429', 'param', '~getChartAttribute()',
                    'Unexpected value of "attribute"');
            }

            // We return 'value' variable here as because it is equivalent to
            // sending '{}' in case above conditions fail.
            return value;
        }
    }, true);
}());



/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,
  eqeqeq: true, plusplus: true, bitwise: true, immed: true */

/*global Array: false, FusionCharts, window: false,
    FusionChartsDataFormats: false */

/*members DOMId, InvalidXMLText, XML, XMLURL, __fusioncharts_dimension,
    __fusioncharts_event, __fusioncharts_vars, addEventListener,
    addVariable, align, allowScriptAccess, animation, appendChild,
    attributes, attrs, autoInstallRedirect, base, bgColor,
    cancelDataLoadRequest, chartHeight, chartWidth, config, configure,
    confirm, core, createElement, dataFormat, dataInvokedOnSWF, dataSource,
    dataURL, dataXML, debugMode, display, embedSWF, encodeURIComponent,
    error, escaped, exec, extend, flashVars, format, getChartData,
    getElementsByTagName, getSWFHTML, getTime, getXML,
    hasFlashPlayerVersion, height, href, id, init, innerHTML,
    installRedirectMessage, isActive, items, lang, location, menu,
    offsetHeight, offsetWidth, options, params, parentNode, policies,
    protocol, prototype, quality, raiseError, raiseEvent, raiseWarning, ref,
    register, registerWithJS, removeChild, removeEventListener, removeSWF,
    render, renderer, replace, requiredFlashPlayerVersion, resize, safeMode,
    salign, scale, scaleMode, sender, setAttribute, setChartData,
    setDataURL, setDataXML, setDefault, setTransparent, showChartMessage,
    source, src, stallLoad, stopPropagation, style, swLiveConnect,
    swfobject, test, toString, toUpperCase, type, unescape, update, url,
    userAgent, wMode, width, data
*/

/**
 * -----------------------------------------------------------------------------
 * Flash Renderer Module
 * -----------------------------------------------------------------------------
 */
(function () {

    // Register the module with FusionCharts and als oget access to a global
    // variable within the core's scope.
    var global = FusionCharts(['private', 'Flash_Renderer']);
    // Check whether the module has been already registered. If true, then
    // do not bother to re-register.
    if (global === undefined) {
        return;
    }

    // Include swfobject in local scope if not already present in the global
    // scope. Make sure to double test original swfobject by testing expected
    // properties of swfobject.
    var swfobject = global.swfobject = function () {

            var UNDEF = "undefined",
                    OBJECT = "object",
                    SHOCKWAVE_FLASH = "Shockwave Flash",
                    SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash",
                    FLASH_MIME_TYPE = "application/x-shockwave-flash",
                    EXPRESS_INSTALL_ID = "SWFObjectExprInst",
                    ON_READY_STATE_CHANGE = "onreadystatechange",

                    win = window,
                    doc = document,
                    nav = navigator,

                    plugin = false,
                    domLoadFnArr = [main],
                    regObjArr = [],
                    objIdArr = [],
                    listenersArr = [],
                    storedAltContent,
                    storedAltContentId,
                    storedCallbackFn,
                    storedCallbackObj,
                    isDomLoaded = false,
                    isExpressInstallActive = false,
                    dynamicStylesheet,
                    dynamicStylesheetMedia,
                    autoHideShow = true,

            /* Centralized function for browser feature detection
                    - User agent string detection is only used when no good alternative is possible
                    - Is executed directly for optimal performance
            */
            ua = function() {
                    var w3cdom = typeof doc.getElementById != UNDEF && typeof doc.getElementsByTagName != UNDEF && typeof doc.createElement != UNDEF,
                            u = nav.userAgent.toLowerCase(),
                            p = nav.platform.toLowerCase(),
                            windows = p ? /win/.test(p) : /win/.test(u),
                            mac = p ? /mac/.test(p) : /mac/.test(u),
                            webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false, // returns either the webkit version or false if not webkit
                            ie = !+"\v1", // feature detection based on Andrea Giammarchi's solution: http://webreflection.blogspot.com/2009/01/32-bytes-to-know-if-your-browser-is-ie.html
                            playerVersion = [0,0,0],
                            d = null;
                    if (typeof nav.plugins != UNDEF && typeof nav.plugins[SHOCKWAVE_FLASH] == OBJECT) {
                            d = nav.plugins[SHOCKWAVE_FLASH].description;
                            if (d && !(typeof nav.mimeTypes != UNDEF && nav.mimeTypes[FLASH_MIME_TYPE] && !nav.mimeTypes[FLASH_MIME_TYPE].enabledPlugin)) { // navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin indicates whether plug-ins are enabled or disabled in Safari 3+
                                    plugin = true;
                                    ie = false; // cascaded feature detection for Internet Explorer
                                    d = d.replace(/^.*\s+(\S+\s+\S+$)/, "$1");
                                    playerVersion[0] = parseInt(d.replace(/^(.*)\..*$/, "$1"), 10);
                                    playerVersion[1] = parseInt(d.replace(/^.*\.(.*)\s.*$/, "$1"), 10);
                                    playerVersion[2] = /[a-zA-Z]/.test(d) ? parseInt(d.replace(/^.*[a-zA-Z]+(.*)$/, "$1"), 10) : 0;
                            }
                    }
                    else if (typeof win.ActiveXObject != UNDEF) {
                            try {
                                    var a = new ActiveXObject(SHOCKWAVE_FLASH_AX);
                                    if (a) { // a will return null when ActiveX is disabled
                                            // Fix for /bug#462
                                            //!// d = a.GetVariable("$version");
                                            try {
                                                d = a.GetVariable("$version");
                                            }
                                            catch (e) { }
                                            // End fix for /bug#462
                                            if (d) {
                                                    ie = true; // cascaded feature detection for Internet Explorer
                                                    d = d.split(" ")[1].split(",");
                                                    playerVersion = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
                                            }
                                    }
                            }
                            catch(e) {}
                    }
                    return {w3:w3cdom, pv:playerVersion, wk:webkit, ie:ie, win:windows, mac:mac};
            }(),

            /* Cross-browser onDomLoad
                    - Will fire an event as soon as the DOM of a web page is loaded
                    - Internet Explorer workaround based on Diego Perini's solution: http://javascript.nwbox.com/IEContentLoaded/
                    - Regular onload serves as fallback
            */
            onDomLoad = function() {
                    if (!ua.w3) {return;}
                    if ((typeof doc.readyState != UNDEF && doc.readyState == "complete") || (typeof doc.readyState == UNDEF && (doc.getElementsByTagName("body")[0] || doc.body))) { // function is fired after onload, e.g. when script is inserted dynamically
                            callDomLoadFunctions();
                    }
                    if (!isDomLoaded) {
                            if (typeof doc.addEventListener != UNDEF) {
                                    doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, false);
                            }
                            if (ua.ie && ua.win) {
                                    doc.attachEvent(ON_READY_STATE_CHANGE, function() {
                                            if (doc.readyState == "complete") {
                                                    doc.detachEvent(ON_READY_STATE_CHANGE, arguments.callee);
                                                    callDomLoadFunctions();
                                            }
                                    });
                                    if (win == top) { // if not inside an iframe
                                            (function(){
                                                    if (isDomLoaded) {return;}
                                                    try {
                                                            doc.documentElement.doScroll("left");
                                                    }
                                                    catch(e) {
                                                            setTimeout(arguments.callee, 0);
                                                            return;
                                                    }
                                                    callDomLoadFunctions();
                                            })();
                                    }
                            }
                            if (ua.wk) {
                                    (function(){
                                            if (isDomLoaded) {return;}
                                            if (!/loaded|complete/.test(doc.readyState)) {
                                                    setTimeout(arguments.callee, 0);
                                                    return;
                                            }
                                            callDomLoadFunctions();
                                    })();
                            }
                            addLoadEvent(callDomLoadFunctions);
                    }
            }();

            function callDomLoadFunctions() {
                    if (isDomLoaded) {return;}
                    try { // test if we can really add/remove elements to/from the DOM; we don't want to fire it too early
                            var t = doc.getElementsByTagName("body")[0].appendChild(createElement("span"));
                            t.parentNode.removeChild(t);
                    }
                    catch (e) {return;}
                    isDomLoaded = true;
                    var dl = domLoadFnArr.length;
                    for (var i = 0; i < dl; i++) {
                            domLoadFnArr[i]();
                    }
            }

            function addDomLoadEvent(fn) {
                    if (isDomLoaded) {
                            fn();
                    }
                    else {
                            domLoadFnArr[domLoadFnArr.length] = fn; // Array.push() is only available in IE5.5+
                    }
            }

            /* Cross-browser onload
                    - Based on James Edwards' solution: http://brothercake.com/site/resources/scripts/onload/
                    - Will fire an event as soon as a web page including all of its assets are loaded
             */
            function addLoadEvent(fn) {
                    if (typeof win.addEventListener != UNDEF) {
                            win.addEventListener("load", fn, false);
                    }
                    else if (typeof doc.addEventListener != UNDEF) {
                            doc.addEventListener("load", fn, false);
                    }
                    else if (typeof win.attachEvent != UNDEF) {
                            addListener(win, "onload", fn);
                    }
                    else if (typeof win.onload == "function") {
                            var fnOld = win.onload;
                            win.onload = function() {
                                    fnOld();
                                    fn();
                            };
                    }
                    else {
                            win.onload = fn;
                    }
            }

            /* Main function
                    - Will preferably execute onDomLoad, otherwise onload (as a fallback)
            */
            function main() {
                    if (plugin) {
                            testPlayerVersion();
                    }
                    else {
                            matchVersions();
                    }
            }

            /* Detect the Flash Player version for non-Internet Explorer browsers
                    - Detecting the plug-in version via the object element is more precise than using the plugins collection item's description:
                      a. Both release and build numbers can be detected
                      b. Avoid wrong descriptions by corrupt installers provided by Adobe
                      c. Avoid wrong descriptions by multiple Flash Player entries in the plugin Array, caused by incorrect browser imports
                    - Disadvantage of this method is that it depends on the availability of the DOM, while the plugins collection is immediately available
            */
            function testPlayerVersion() {
                    var b = doc.getElementsByTagName("body")[0];
                    var o = createElement(OBJECT);
                    o.setAttribute("type", FLASH_MIME_TYPE);
                    var t = b.appendChild(o);
                    if (t) {
                            var counter = 0;
                            (function(){
                                    if (typeof t.GetVariable != UNDEF) {
                                            // Fix for /bug#462
                                            //!// var d = t.GetVariable("$version");
                                            var d;
                                            try {
                                                d = t.GetVariable("$version");
                                            }
                                            catch (e) { }
                                            // End fix for /bug#462
                                            if (d) {
                                                    d = d.split(" ")[1].split(",");
                                                    ua.pv = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
                                            }
                                    }
                                    else if (counter < 10) {
                                            counter++;
                                            setTimeout(arguments.callee, 10);
                                            return;
                                    }
                                    b.removeChild(o);
                                    t = null;
                                    matchVersions();
                            })();
                    }
                    else {
                            matchVersions();
                    }
            }

            /* Perform Flash Player and SWF version matching; static publishing only
            */
            function matchVersions() {
                    var rl = regObjArr.length;
                    if (rl > 0) {
                            for (var i = 0; i < rl; i++) { // for each registered object element
                                    var id = regObjArr[i].id;
                                    var cb = regObjArr[i].callbackFn;
                                    var cbObj = {success:false, id:id};
                                    if (ua.pv[0] > 0) {
                                            var obj = getElementById(id);
                                            if (obj) {
                                                    if (hasPlayerVersion(regObjArr[i].swfVersion) && !(ua.wk && ua.wk < 312)) { // Flash Player version >= published SWF version: Houston, we have a match!
                                                            setVisibility(id, true);
                                                            if (cb) {
                                                                    cbObj.success = true;
                                                                    cbObj.ref = getObjectById(id);
                                                                    cb(cbObj);
                                                            }
                                                    }
                                                    else if (regObjArr[i].expressInstall && canExpressInstall()) { // show the Adobe Express Install dialog if set by the web page author and if supported
                                                            var att = {};
                                                            att.data = regObjArr[i].expressInstall;
                                                            att.width = obj.getAttribute("width") || "0";
                                                            att.height = obj.getAttribute("height") || "0";
                                                            if (obj.getAttribute("class")) {att.styleclass = obj.getAttribute("class");}
                                                            if (obj.getAttribute("align")) {att.align = obj.getAttribute("align");}
                                                            // parse HTML object param element's name-value pairs
                                                            var par = {};
                                                            var p = obj.getElementsByTagName("param");
                                                            var pl = p.length;
                                                            for (var j = 0; j < pl; j++) {
                                                                    if (p[j].getAttribute("name").toLowerCase() != "movie") {
                                                                            par[p[j].getAttribute("name")] = p[j].getAttribute("value");
                                                                    }
                                                            }
                                                            showExpressInstall(att, par, id, cb);
                                                    }
                                                    else { // Flash Player and SWF version mismatch or an older Webkit engine that ignores the HTML object element's nested param elements: display alternative content instead of SWF
                                                            displayAltContent(obj);
                                                            if (cb) {cb(cbObj);}
                                                    }
                                            }
                                    }
                                    else {	// if no Flash Player is installed or the fp version cannot be detected we let the HTML object element do its job (either show a SWF or alternative content)
                                            setVisibility(id, true);
                                            if (cb) {
                                                    var o = getObjectById(id); // test whether there is an HTML object element or not
                                                    if (o && typeof o.SetVariable != UNDEF) {
                                                            cbObj.success = true;
                                                            cbObj.ref = o;
                                                    }
                                                    cb(cbObj);
                                            }
                                    }
                            }
                    }
            }

            function getObjectById(objectIdStr) {
                    var r = null;
                    var o = getElementById(objectIdStr);
                    if (o && o.nodeName == "OBJECT") {
                            if (typeof o.SetVariable != UNDEF) {
                                    r = o;
                            }
                            else {
                                    var n = o.getElementsByTagName(OBJECT)[0];
                                    if (n) {
                                            r = n;
                                    }
                            }
                    }
                    return r;
            }

            /* Requirements for Adobe Express Install
                    - only one instance can be active at a time
                    - fp 6.0.65 or higher
                    - Win/Mac OS only
                    - no Webkit engines older than version 312
            */
            function canExpressInstall() {
                    return !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac) && !(ua.wk && ua.wk < 312);
            }

            /* Show the Adobe Express Install dialog
                    - Reference: http://www.adobe.com/cfusion/knowledgebase/index.cfm?id=6a253b75
            */
            function showExpressInstall(att, par, replaceElemIdStr, callbackFn) {
                    isExpressInstallActive = true;
                    storedCallbackFn = callbackFn || null;
                    storedCallbackObj = {success:false, id:replaceElemIdStr};
                    var obj = getElementById(replaceElemIdStr);
                    if (obj) {
                            if (obj.nodeName == "OBJECT") { // static publishing
                                    storedAltContent = abstractAltContent(obj);
                                    storedAltContentId = null;
                            }
                            else { // dynamic publishing
                                    storedAltContent = obj;
                                    storedAltContentId = replaceElemIdStr;
                            }
                            att.id = EXPRESS_INSTALL_ID;
                            if (typeof att.width == UNDEF || (!/%$/.test(att.width) && parseInt(att.width, 10) < 310)) {att.width = "310";}
                            if (typeof att.height == UNDEF || (!/%$/.test(att.height) && parseInt(att.height, 10) < 137)) {att.height = "137";}
                            doc.title = doc.title.slice(0, 47) + " - Flash Player Installation";
                            var pt = ua.ie && ua.win ? "ActiveX" : "PlugIn",
                                    fv = "MMredirectURL=" + win.location.toString().replace(/&/g,"%26") + "&MMplayerType=" + pt + "&MMdoctitle=" + doc.title;
                            if (typeof par.flashvars != UNDEF) {
                                    par.flashvars += "&" + fv;
                            }
                            else {
                                    par.flashvars = fv;
                            }
                            // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it,
                            // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work
                            if (ua.ie && ua.win && obj.readyState != 4) {
                                    var newObj = createElement("div");
                                    replaceElemIdStr += "SWFObjectNew";
                                    newObj.setAttribute("id", replaceElemIdStr);
                                    obj.parentNode.insertBefore(newObj, obj); // insert placeholder div that will be replaced by the object element that loads expressinstall.swf
                                    obj.style.display = "none";
                                    (function(){
                                            if (obj.readyState == 4) {
                                                    obj.parentNode.removeChild(obj);
                                            }
                                            else {
                                                    setTimeout(arguments.callee, 10);
                                            }
                                    })();
                            }
                            createSWF(att, par, replaceElemIdStr);
                    }
            }

            /* Functions to abstract and display alternative content
            */
            function displayAltContent(obj) {
                    if (ua.ie && ua.win && obj.readyState != 4) {
                            // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it,
                            // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work
                            var el = createElement("div");
                            obj.parentNode.insertBefore(el, obj); // insert placeholder div that will be replaced by the alternative content
                            el.parentNode.replaceChild(abstractAltContent(obj), el);
                            obj.style.display = "none";
                            (function(){
                                    if (obj.readyState == 4) {
                                            obj.parentNode.removeChild(obj);
                                    }
                                    else {
                                            setTimeout(arguments.callee, 10);
                                    }
                            })();
                    }
                    else {
                            obj.parentNode.replaceChild(abstractAltContent(obj), obj);
                    }
            }

            function abstractAltContent(obj) {
                    var ac = createElement("div");
                    if (ua.win && ua.ie) {
                            ac.innerHTML = obj.innerHTML;
                    }
                    else {
                            var nestedObj = obj.getElementsByTagName(OBJECT)[0];
                            if (nestedObj) {
                                    var c = nestedObj.childNodes;
                                    if (c) {
                                            var cl = c.length;
                                            for (var i = 0; i < cl; i++) {
                                                    if (!(c[i].nodeType == 1 && c[i].nodeName == "PARAM") && !(c[i].nodeType == 8)) {
                                                            ac.appendChild(c[i].cloneNode(true));
                                                    }
                                            }
                                    }
                            }
                    }
                    return ac;
            }

            /* Cross-browser dynamic SWF creation
            */
            function createSWF(attObj, parObj, id) {
                    var r, el = getElementById(id);
                    if (ua.wk && ua.wk < 312) {return r;}
                    if (el) {
                            if (typeof attObj.id == UNDEF) { // if no 'id' is defined for the object element, it will inherit the 'id' from the alternative content
                                    attObj.id = id;
                            }
                            if (ua.ie && ua.win) { // Internet Explorer + the HTML object element + W3C DOM methods do not combine: fall back to outerHTML
                                    var att = "";
                                    for (var i in attObj) {
                                            if (attObj[i] != Object.prototype[i]) { // filter out prototype additions from other potential libraries
                                                    if (i.toLowerCase() == "data") {
                                                            parObj.movie = attObj[i];
                                                    }
                                                    else if (i.toLowerCase() == "styleclass") { // 'class' is an ECMA4 reserved keyword
                                                            att += ' class="' + attObj[i] + '"';
                                                    }
                                                    else if (i.toLowerCase() != "classid") {
                                                            att += ' ' + i + '="' + attObj[i] + '"';
                                                    }
                                            }
                                    }
                                    var par = "";
                                    for (var j in parObj) {
                                            if (parObj[j] != Object.prototype[j]) { // filter out prototype additions from other potential libraries
                                                    par += '<param name="' + j + '" value="' + parObj[j] + '" />';
                                            }
                                    }
                                    el.outerHTML = '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"' + att + '>' + par + '</object>';
                                    objIdArr[objIdArr.length] = attObj.id; // stored to fix object 'leaks' on unload (dynamic publishing only)
                                    r = getElementById(attObj.id);
                            }
                            else { // well-behaving browsers
                                    var o = createElement(OBJECT);
                                    o.setAttribute("type", FLASH_MIME_TYPE);
                                    for (var m in attObj) {
                                            if (attObj[m] != Object.prototype[m]) { // filter out prototype additions from other potential libraries
                                                    if (m.toLowerCase() == "styleclass") { // 'class' is an ECMA4 reserved keyword
                                                            o.setAttribute("class", attObj[m]);
                                                    }
                                                    else if (m.toLowerCase() != "classid") { // filter out IE specific attribute
                                                            o.setAttribute(m, attObj[m]);
                                                    }
                                            }
                                    }
                                    for (var n in parObj) {
                                            if (parObj[n] != Object.prototype[n] && n.toLowerCase() != "movie") { // filter out prototype additions from other potential libraries and IE specific param element
                                                    createObjParam(o, n, parObj[n]);
                                            }
                                    }
                                    el.parentNode.replaceChild(o, el);
                                    r = o;
                            }
                    }
                    return r;
            }

            function createObjParam(el, pName, pValue) {
                    var p = createElement("param");
                    p.setAttribute("name", pName);
                    p.setAttribute("value", pValue);
                    el.appendChild(p);
            }

            /* Cross-browser SWF removal
                    - Especially needed to safely and completely remove a SWF in Internet Explorer
            */
            function removeSWF(id) {
                    var obj = getElementById(id);
                    if (obj && obj.nodeName == "OBJECT") {
                            if (ua.ie && ua.win) {
                                    obj.style.display = "none";
                                    (function(){
                                            if (obj.readyState == 4) {
                                                    removeObjectInIE(id);
                                            }
                                            else {
                                                    setTimeout(arguments.callee, 10);
                                            }
                                    })();
                            }
                            else {
                                    obj.parentNode.removeChild(obj);
                            }
                    }
            }

            function removeObjectInIE(id) {
                    var obj = getElementById(id);
                    if (obj) {
                            for (var i in obj) {
                                    if (typeof obj[i] == "function") {
                                            obj[i] = null;
                                    }
                            }
                            obj.parentNode.removeChild(obj);
                    }
            }

            /* Functions to optimize JavaScript compression
            */
            function getElementById(id) {
                    var el = null;
                    try {
                            el = doc.getElementById(id);
                    }
                    catch (e) {}
                    return el;
            }

            function createElement(el) {
                    return doc.createElement(el);
            }

            /* Updated attachEvent function for Internet Explorer
                    - Stores attachEvent information in an Array, so on unload the detachEvent functions can be called to avoid memory leaks
            */
            function addListener(target, eventType, fn) {
                    target.attachEvent(eventType, fn);
                    listenersArr[listenersArr.length] = [target, eventType, fn];
            }

            /* Flash Player and SWF content version matching
            */
            function hasPlayerVersion(rv) {
                    var pv = ua.pv, v = rv.split(".");
                    v[0] = parseInt(v[0], 10);
                    v[1] = parseInt(v[1], 10) || 0; // supports short notation, e.g. "9" instead of "9.0.0"
                    v[2] = parseInt(v[2], 10) || 0;
                    return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false;
            }

            /* Cross-browser dynamic CSS creation
                    - Based on Bobby van der Sluis' solution: http://www.bobbyvandersluis.com/articles/dynamicCSS.php
            */
            function createCSS(sel, decl, media, newStyle) {
                    if (ua.ie && ua.mac) {return;}
                    var h = doc.getElementsByTagName("head")[0];
                    if (!h) {return;} // to also support badly authored HTML pages that lack a head element
                    var m = (media && typeof media == "string") ? media : "screen";
                    if (newStyle) {
                            dynamicStylesheet = null;
                            dynamicStylesheetMedia = null;
                    }
                    if (!dynamicStylesheet || dynamicStylesheetMedia != m) {
                            // create dynamic stylesheet + get a global reference to it
                            var s = createElement("style");
                            s.setAttribute("type", "text/css");
                            s.setAttribute("media", m);
                            dynamicStylesheet = h.appendChild(s);
                            if (ua.ie && ua.win && typeof doc.styleSheets != UNDEF && doc.styleSheets.length > 0) {
                                    dynamicStylesheet = doc.styleSheets[doc.styleSheets.length - 1];
                            }
                            dynamicStylesheetMedia = m;
                    }
                    // add style rule
                    if (ua.ie && ua.win) {
                            if (dynamicStylesheet && typeof dynamicStylesheet.addRule == OBJECT) {
                                    dynamicStylesheet.addRule(sel, decl);
                            }
                    }
                    else {
                            if (dynamicStylesheet && typeof doc.createTextNode != UNDEF) {
                                    dynamicStylesheet.appendChild(doc.createTextNode(sel + " {" + decl + "}"));
                            }
                    }
            }

            function setVisibility(id, isVisible) {
                    if (!autoHideShow) {return;}
                    var v = isVisible ? "visible" : "hidden";
                    if (isDomLoaded && getElementById(id)) {
                            getElementById(id).style.visibility = v;
                    }
                    else {
                            createCSS("#" + id, "visibility:" + v);
                    }
            }

            /* Filter to avoid XSS attacks
            */
            function urlEncodeIfNecessary(s) {
                    var regex = /[\\\"<>\.;]/;
                    var hasBadChars = regex.exec(s) != null;
                    return hasBadChars && typeof encodeURIComponent != UNDEF ? encodeURIComponent(s) : s;
            }

            /* Release memory to avoid memory leaks caused by closures, fix hanging audio/video threads and force open sockets/NetConnections to disconnect (Internet Explorer only)
            */
            var cleanup = function() {
                    if (ua.ie && ua.win) {
                            window.attachEvent("onunload", function() {
                                    // remove listeners to avoid memory leaks
                                    var ll = listenersArr.length;
                                    for (var i = 0; i < ll; i++) {
                                            listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]);
                                    }
                                    // cleanup dynamically embedded objects to fix audio/video threads and force open sockets and NetConnections to disconnect
                                    var il = objIdArr.length;
                                    for (var j = 0; j < il; j++) {
                                            removeSWF(objIdArr[j]);
                                    }
                                    // cleanup library's main closures to avoid memory leaks
                                    for (var k in ua) {
                                            ua[k] = null;
                                    }
                                    ua = null;
                                    for (var l in swfobject) {
                                            swfobject[l] = null;
                                    }
                                    swfobject = null;
                            });
                    }
            }();

            return {
                    /* Public API
                            - Reference: http://code.google.com/p/swfobject/wiki/documentation
                    */
                    registerObject: function(objectIdStr, swfVersionStr, xiSwfUrlStr, callbackFn) {
                            if (ua.w3 && objectIdStr && swfVersionStr) {
                                    var regObj = {};
                                    regObj.id = objectIdStr;
                                    regObj.swfVersion = swfVersionStr;
                                    regObj.expressInstall = xiSwfUrlStr;
                                    regObj.callbackFn = callbackFn;
                                    regObjArr[regObjArr.length] = regObj;
                                    setVisibility(objectIdStr, false);
                            }
                            else if (callbackFn) {
                                    callbackFn({success:false, id:objectIdStr});
                            }
                    },

                    getObjectById: function(objectIdStr) {
                            if (ua.w3) {
                                    return getObjectById(objectIdStr);
                            }
                    },

                    embedSWF: function(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, callbackFn) {
                            var callbackObj = {success:false, id:replaceElemIdStr};
                            if (ua.w3 && !(ua.wk && ua.wk < 312) && swfUrlStr && replaceElemIdStr && widthStr && heightStr && swfVersionStr) {
                                    setVisibility(replaceElemIdStr, false);
                                    addDomLoadEvent(function() {
                                            widthStr += ""; // auto-convert to string
                                            heightStr += "";
                                            var att = {};
                                            if (attObj && typeof attObj === OBJECT) {
                                                    for (var i in attObj) { // copy object to avoid the use of references, because web authors often reuse attObj for multiple SWFs
                                                            att[i] = attObj[i];
                                                    }
                                            }
                                            att.data = swfUrlStr;
                                            att.width = widthStr;
                                            att.height = heightStr;
                                            var par = {};
                                            if (parObj && typeof parObj === OBJECT) {
                                                    for (var j in parObj) { // copy object to avoid the use of references, because web authors often reuse parObj for multiple SWFs
                                                            par[j] = parObj[j];
                                                    }
                                            }
                                            if (flashvarsObj && typeof flashvarsObj === OBJECT) {
                                                    for (var k in flashvarsObj) { // copy object to avoid the use of references, because web authors often reuse flashvarsObj for multiple SWFs
                                                            if (typeof par.flashvars != UNDEF) {
                                                                    par.flashvars += "&" + k + "=" + flashvarsObj[k];
                                                            }
                                                            else {
                                                                    par.flashvars = k + "=" + flashvarsObj[k];
                                                            }
                                                    }
                                            }
                                            if (hasPlayerVersion(swfVersionStr)) { // create SWF
                                                    var obj = createSWF(att, par, replaceElemIdStr);
                                                    if (att.id == replaceElemIdStr) {
                                                            setVisibility(replaceElemIdStr, true);
                                                    }
                                                    callbackObj.success = true;
                                                    callbackObj.ref = obj;
                                            }
                                            else if (xiSwfUrlStr && canExpressInstall()) { // show Adobe Express Install
                                                    att.data = xiSwfUrlStr;
                                                    showExpressInstall(att, par, replaceElemIdStr, callbackFn);
                                                    return;
                                            }
                                            else { // show alternative content
                                                    setVisibility(replaceElemIdStr, true);
                                            }
                                            if (callbackFn) {callbackFn(callbackObj);}
                                    });
                            }
                            else if (callbackFn) {callbackFn(callbackObj);}
                    },

                    switchOffAutoHideShow: function() {
                            autoHideShow = false;
                    },

                    ua: ua,

                    getFlashPlayerVersion: function() {
                            return {major:ua.pv[0], minor:ua.pv[1], release:ua.pv[2]};
                    },

                    hasFlashPlayerVersion: hasPlayerVersion,

                    createSWF: function(attObj, parObj, replaceElemIdStr) {
                            if (ua.w3) {
                                    return createSWF(attObj, parObj, replaceElemIdStr);
                            }
                            else {
                                    return undefined;
                            }
                    },

                    showExpressInstall: function(att, par, replaceElemIdStr, callbackFn) {
                            if (ua.w3 && canExpressInstall()) {
                                    showExpressInstall(att, par, replaceElemIdStr, callbackFn);
                            }
                    },

                    removeSWF: function(objElemIdStr) {
                            if (ua.w3) {
                                    removeSWF(objElemIdStr);
                            }
                    },

                    createCSS: function(selStr, declStr, mediaStr, newStyleBoolean) {
                            if (ua.w3) {
                                    createCSS(selStr, declStr, mediaStr, newStyleBoolean);
                            }
                    },

                    addDomLoadEvent: addDomLoadEvent,

                    addLoadEvent: addLoadEvent,

                    getQueryParamValue: function(param) {
                            var q = doc.location.search || doc.location.hash;
                            if (q) {
                                    if (/\?/.test(q)) {q = q.split("?")[1];} // strip question mark
                                    if (param == null) {
                                            return urlEncodeIfNecessary(q);
                                    }
                                    var pairs = q.split("&");
                                    for (var i = 0; i < pairs.length; i++) {
                                            if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) {
                                                    return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1)));
                                            }
                                    }
                            }
                            return "";
                    },

                    // For internal usage only
                    expressInstallCallback: function() {
                            if (isExpressInstallActive) {
                                    var obj = getElementById(EXPRESS_INSTALL_ID);
                                    if (obj && storedAltContent) {
                                            obj.parentNode.replaceChild(storedAltContent, obj);
                                            if (storedAltContentId) {
                                                    setVisibility(storedAltContentId, true);
                                                    if (ua.ie && ua.win) {storedAltContent.style.display = "block";}
                                            }
                                            if (storedCallbackFn) {storedCallbackFn(storedCallbackObj);}
                                    }
                                    isExpressInstallActive = false;
                            }
                    }
            };
    }();


    // Set flags for minimum version of flash-player needed.
    global.core.options.requiredFlashPlayerVersion = '8';
    // Message to show upon auto install redirect.
    global.core.options.installRedirectMessage = 'You need Adobe Flash ' +
        'Player 8 (or above) to view the charts on this page. It is a free, ' +
        'lightweight and safe installation from Adobe Systems Incorporated.' +
        '\n\nWould you like to go to Adobe\'s website and install Flash Player?';

    var noFlashRedirectNotified = false;

    // To avoid XSS attacks, we URLEncode FlashVars.
    var checkBadChars = /[\\\"<>;]/;
    var urlEncodeIfNecessary = function (s) {
        return (checkBadChars.exec(s) !== null) &&
            typeof window.encodeURIComponent !== undefined ?
            window.encodeURIComponent(s) : s;
    };

        /**
     * Event listener that updates local chart data when there has
     * been a remote data update on renderer.
     */
    var syncDataStore =  function (e, a) {

        // Verify whether the event has been raised by JS or by Flash.
        // If event has been raised by JS, we do not need to do
        // anything further.

        if (a && a.source === 'XmlHttpRequest') {
            return;
        }

        // Reference to chartObj.
        var obj = e.sender;

        // Test whether the required functions are available.
        if (obj.ref && typeof obj.ref.dataInvokedOnSWF === 'function' &&
            obj.ref.dataInvokedOnSWF() && typeof obj.ref.getXML === 'function') {

            // Raise a warning for the same.
            global.raiseWarning(obj, '08300116', 'run',
                '::DataHandler~__fusioncharts_vars',
                'Data was set in UTF unsafe manner');

            // Silently update/sync the internal data of FusionCharts JS
            // objects with the new data that was directly sent to flash.
            obj.setChartData(window.unescape(e.sender.ref.getXML({
                escaped: true
            })), FusionChartsDataFormats.XML, true);

            // Update the flashVars as well.
            obj.flashVars.dataXML = obj.getChartData(FusionChartsDataFormats.XML);

            // Since further data communication involves the presence of
            // data-xml in state, we remove the dataURL from flashVars and
            // keep XML fetched from chart.
            delete obj.flashVars.dataURL;
        }

        // Remove ebent handler association so that normal dataLoad is not
        // intercepted.
        e.sender.removeEventListener('DataLoaded', syncDataStore);
    };


    // This code-block exposes a function that assists FusionCharts swf objects
    // to receive updated and accurate dimension information in case of
    // percentage size.
    window.__fusioncharts_dimension = (function () {

        // Regular expression to match whether a right trimmedstring ends with
        // percentage sign or not.
        var isPercentRegex = /.*?\%\s*?$/g;

        // No point documenting this piece of unreadable code! In short, it
        // simply calculates the width of the chart based on the offsetWidth of
        // the container. Same is for height.
        return function (id) {
            var obj, parent;
            return !((obj = global.core(id)) instanceof global.core &&
                obj.ref && (parent = obj.ref.parentNode)) ? {} : {
                width: parent.offsetWidth * (isPercentRegex.test(obj.width) ?
                    parseInt(obj.width, 10) / 100 : 1),
                height: parent.offsetHeight * (isPercentRegex.test(obj.height) ?
                    parseInt(obj.height, 10) / 100 : 1)
            };
        };
    }());

    // Routines to manage state between SWF and FusionCharts JS Object
    window.__fusioncharts_vars = function (id, vars) {

        var obj = global.core.items[id];

        // Verify whether corresponding FusionCharts object exists.
        if (!(obj instanceof global.core)) {
            // Throw error when FusionCharts obj not found.
            global.raiseError(global.core, '25081621', 'run', '::FlashRenderer',
                'FusionCharts Flash object is accessing flashVars of non-existent object.');
            return false;
        }

        // When 'vars' parameter is sent, we sync the local vars object
        if (typeof vars === 'object') {

            // We check whether there was a direct update of data on SWF. In
            // case it is true, we proceed with datastore sync.
            if (obj.ref && typeof obj.ref.dataInvokedOnSWF === 'function' &&
                obj.ref.dataInvokedOnSWF()) {

                // In case dataURL has been updated, we probe into an event that
                // updates local dataStore
                if (vars.dataURL !== undefined) {
                    obj.addEventListener('DataLoaded', syncDataStore);
                }
                // Specifically unescape the dataXML updated
                else if (vars.dataXML !== undefined) {
                    vars.dataXML = window.unescape(vars.dataXML);
                }
            }
            else {
                // Clear data related variables to prevent sync with local
                // store.
                delete vars.dataURL;
                delete vars.dataXML;
            }

            // If corresponding FusionCharts object is found, we update the
            // vars.
            global.extend(obj.flashVars, vars);

            return true;
        }

        return obj.flashVars;
    };

    // Adjust flash dimension based upon flashVars
    global.addEventListener('BeforeInitialize', function (event) {
        // Get short reference to the event sender.
        var obj = event.sender;

        // Filter objects that are generated by flash renderer only.
        if (obj.options.renderer !== 'flash') {
            return;
        }

        // Prevention is better than cure. So is precaution!
        if (obj.width === undefined) {
            obj.width = global.renderer.policies.flashVars.chartWidth[1];
        }
        if (obj.height === undefined) {
            obj.height = global.renderer.policies.flashVars.chartHeight[1];
        }
        if (obj.flashVars.DOMId === undefined) {
            obj.flashVars.DOMId = obj.id;
        }

        // Default flashVars that are to be set.
        global.extend(obj.flashVars, {
            registerWithJS: '1',
            chartWidth: obj.width,
            chartHeight: obj.height,
            InvalidXMLText: 'Invalid data.'
        });
 
        // AutoInstallRedirect action routine.
        if (Boolean(obj.options.autoInstallRedirect) === true &&
            !global.swfobject.hasFlashPlayerVersion(
                global.core.options.requiredFlashPlayerVersion.toString()) &&
            noFlashRedirectNotified === false) {
            noFlashRedirectNotified = true;
            if (window.confirm(global.core.options.installRedirectMessage)) {
                window.location.href = 'http://get.adobe.com/flashplayer/';
            }
        }

        // Set initial state of charts
        if (obj.options.dataFormat === undefined && obj.options.dataSource === undefined) {
            obj.options.dataFormat = FusionChartsDataFormats.XMLURL;
            obj.options.dataSource = 'Data.xml';
        }
    });

    
    // Add method to make sure to delete all fusioncharts objects when
    // dispose method is invoked
    global.addEventListener('Disposed', function (e) {
        // Process these events only for objects that have flash renderer!
        if (e.sender.options.renderer !== 'flash') {
            return;
        }
        // Managed removal of chart using swfObject library
        global.swfobject.removeSWF(e.sender.id);
    });

    global.addEventListener('Loaded', function (e) {
        // Process these events only for objects that have flash renderer!
        if (e.sender.options.renderer !== 'flash') {
            return;
        }

        // Upon render completion, disable animation of the chart by updating the
        // 'animation' flag in flashVars. This fixes the issue of FusionCharts
        // loosing its state when it is re-rendered after being hidden.
        // Set disable animation flag for state management.
        e.sender.flashVars.animation = '0';
    });

    global.addEventListener('DataLoadRequested', function (event, args) {
        // Reference to event sender.
        var obj = event.sender;

        // Process these events only for objects that have flash renderer!
        if (obj.options.renderer !== 'flash') {
            return;
        }
        if (window.location.protocol === 'file:' && args.dataFormat === 
            FusionChartsDataFormats.XML && Boolean(obj.options.safeMode) === true) {
            if (obj.ref && obj.ref.setDataURL) {
                obj.ref.setDataURL(args.url, false);
            }
            else {
                obj.flashVars.dataURL = args.url;
            }
            // Stop further activities on this event.
            event.stopPropagation();
            
            // Cancel the AJAX data-load request.
            args.cancelDataLoadRequest();
            obj.addEventListener('DataLoaded', syncDataStore);
        }

        // In case we have an active chart, we show the loading
        // message in chart itself.
        if (obj.ref && typeof obj.showChartMessage === 'function') {
            delete obj.flashVars.stallLoad;
            obj.ref.showChartMessage('XMLLoadingText');
        }
        // In case chart object is not available, we set a flashvar saying that
        // loading is to be stalled.
        else {
            obj.flashVars.stallLoad = true;
        }
    });

    global.addEventListener('DataLoadRequestCancelled', function (event) {
        // Reference to event sender.
        var obj = event.sender;

        // Process these events only for objects that have flash renderer!
        if (obj.options.renderer !== 'flash') {
            return;
        }

        // In case we have an active chart, we hide the loading message in chart
        // itself.
        if (obj.ref && typeof obj.showChartMessage === 'function') {
            obj.ref.showChartMessage();
        }
        // In case chart object is not available, we set a flashvar saying that
        // loading is to be stalled.
        delete obj.flashVars.stallLoad;
    });

    global.addEventListener('DataLoadError', function (event, args) {
        // Reference to event sender.
        var obj = event.sender;

        // Process these events only for objects that have flash renderer!
        if (obj.options.renderer !== 'flash') {
            return;
        }

        // On data load error, one needs to display "No Data To Display" on
        // charts.
        if (obj.ref && typeof obj.ref.showChartMessage === 'function' &&
            args.source === 'XmlHttpRequest') {
            // Show Data Load Error Message.
            obj.ref.showChartMessage('LoadDataErrorText');
        }
        else {
            delete obj.flashVars.dataURL;// = 'XmlHttpRequestDataLoadError: ' + args.url;
            obj.flashVars.dataXML = '<JSON parsing error>';
            delete obj.flashVars.stallLoad;
        }

    });

    global.addEventListener('DataLoadRequestCompleted', function (event, args) {
        // Reference to event sender.
        var obj = event.sender;

        // Process these events only for objects that have flash renderer!
        if (obj.options.renderer !== 'flash' || args.source !== 'XmlHttpRequest') {
            return;
        }

        // Clear load prevention flag.
        delete obj.flashVars.stallLoad;

    });
    

    // Bind EventTarget with the FusionCharts global event handler
    window.__fusioncharts_event = function (event, args) {
        // Create an abstraction layer so that the try-catch / error suppression
        // of flash can be avoided.
        setTimeout(function () {
            global.raiseEvent(event.type, args, global.core.items[event.sender]);
        }, 0);
    };

    var renderer = {
        // Default data format supported by this renderer
        dataFormat: 'xml',
        
        init: function () {

        },
        
        policies: {
            // Add construction policies specific to ActiveX parameters.
            params: {
                scaleMode: ['scaleMode', 'noScale'],
                scale: ['scaleMode', 'noScale'],
                wMode: ['wMode', 'opaque'],
                menu: ['menu', undefined],
                bgColor: ['bgColor', undefined],
                allowScriptAccess: ['allowScriptAccess', 'always'],
                quality: ['quality', 'best'],
                swLiveConnect: ['swLiveConnect', undefined],
                base: ['base', undefined],
                align: ['align', undefined],
                salign: ['sAlign', undefined]
            },
            /**
             * @var vars {object} Contains all the veriables that are local to every
             * renderer. This has a direct implication to the FlashVars of the
             * 'flash' renderer.
             */
            flashVars: {
                lang: ['lang', 'EN'],
                debugMode: ['debugMode', undefined],
                // @note: Deprecated and hardcoded in beforeinitialize event.
                // registerWithJS: ['registerWithJS', '1'],
                animation: ['animate', undefined]
            },

            options: {
                autoInstallRedirect: ['autoInstallRedirect', false]
            }
        },

        render: function (container, callBack) {

            // Remove the 'animation' flag of the chart.
            if (Boolean(this.flashVars.animation) === true) {
                delete this.flashVars.animation;
            }

            // Check for valid 'src' attribute
            if (!this.src) {
                global.raiseError(this, '03102348', 'run', '::FlashRenderer.render',
                    'Could not find a valid "src" attribute. swfUrl or chart ' +
                    'type missing.');
            }

            // Copy the flashVars and encodeURIComponent all of them before
            // sending to swfObject
            var encodedVars = {}, dataXML = this.flashVars.dataXML,
                dataURL = this.flashVars.dataURL;
            global.extend(encodedVars, this.flashVars);

            // For backward compatibility, set the flashVar to have reference
            // to xml or xmlurl in case render is called while the charts are
            // flagged to be stalled.
            if (this.flashVars.stallLoad === true) {
                if (this.options.dataFormat === FusionChartsDataFormats.XML) {
                    dataXML = this.options.dataSource;
                }
                if (this.options.dataFormat === FusionChartsDataFormats.XMLURL) {
                    dataURL = this.options.dataSource;
                }
            }

            // Encode dataXML and dataURL
            encodedVars.dataXML = window.encodeURIComponent(dataXML || '');
            encodedVars.dataURL = urlEncodeIfNecessary(dataURL || '');

            // Call swfobject API to render the chart
            global.swfobject.embedSWF(this.src, this.id, this.width,
                this.height, '8.0.0', undefined, encodedVars, this.params,
                this.attributes, callBack);

        },

        // Listen to the dataUpdated event, so that charts can be re-rendered with
        // new data, when data is updated on JS variable post render
        update: function (vars) {
            // Point to direct SWFObject and also get the latest data
            var chart = this.ref, data = vars.data;

            // When updating states that dataXML has been updated
            // Update FlashVars
            this.flashVars.dataXML = data;

            // Check whether there was an error or not.
            if (vars.error === undefined) {
                // Call ExternalInterface method and update the data
                if (this.isActive() && typeof chart.setDataXML === 'function') {
                    chart.setDataXML(data, false);
                }
                else {
                    // Remove the 'animation' flag of the chart while data was
                    // updated during unavailability of SWF
                    delete this.flashVars.dataURL;
                    delete this.flashVars.animation;
                }
            }
            // Show error message.
            else {
                // Call ExternalInterface method to show message
                if (this.isActive() && typeof chart.showChartMessage === 'function') {
                    chart.showChartMessage('InvalidXMLText');
                }
                else {
                    // Remove the 'animation' flag of the chart while data was
                    // updated during unavailability of SWF
                    this.flashVars.dataXML = '<Invalid' + vars.format.toUpperCase() + '>';
                    delete this.flashVars.dataURL;
                    delete this.flashVars.animation;
                }
            }
        },
        
        // Handle renderer resize.
        resize: function () {
            // Updated flashVars with new dimension
            this.flashVars.chartWidth = this.width;
            this.flashVars.chartHeight = this.height;

            if (this.ref !== undefined) {
                // Set sizes of DOM elements.
                this.ref.width = this.width;
                this.ref.height = this.height;
                if (typeof this.ref.resize === 'function') {
                    // Force resize on charts.
                    this.ref.resize(this.ref.offsetWidth, this.ref.offsetHeight);
                }
            }
        },

        // Send chart configuration
        config: function (items) {
            global.extend(this.flashVars, items);
        }
    };

    // Add flash renderer legacy functions.
    renderer.prototype = {
        // Legacy function
        getSWFHTML: function () {

            // Create temporary elements and temporary access Id
            var outElm = document.createElement('span'),
                inElm = document.createElement('span'),
                tempId = 'RnVzaW9uQ2hhcnRz' + (new Date()).getTime();

            // Create DOM hierarchy
            outElm.appendChild(inElm);
            // Specify temp access Id
            inElm.setAttribute('id', tempId);
            // Hide this element from user.
            outElm.style.display = 'none';
            // Add the element to DOM.
            document.getElementsByTagName('body')[0].appendChild(outElm);

            // Temporarily embed the swf in the above-created element.
            global.swfobject.embedSWF(this.src, tempId, this.width,
                this.height, '8.0.0', undefined, this.flashVars, this.params,
                this.attrs);

            // Get the HTML from the temp objects.
            var html = outElm.innerHTML.replace(tempId, this.id);

            // Clean up the dirty work.
            global.swfobject.removeSWF(tempId);
            outElm.parentNode.removeChild(outElm);

            // Return the HTML with its ID set to normal.
            return html;
        },

        // Add legacy setTransparent function
        setTransparent: function (transparency) {
            // Sets chart to transparent mode when isTransparent (wMode) is true
            // (default). When no parameter is passed, we assume transparent to
            // be true.
            if (typeof transparency !== 'boolean' && transparency !== null) {
                transparency = true;
            }

            // Set the property.
            this.params.wMode = transparency === null ? 'window' :
                (transparency === true ? 'transparent' : 'opaque');
        },

        addVariable: global.core.prototype.configure
    };

    // Add the renderer to FusionCharts core repository
    global.renderer.register('flash', renderer);

    // Check for flash and iphone/ipad
    // Register the swf renderer in case we have flashPlayer.
    if (!/\(iPhone;|\(iPad;/i.test(navigator.userAgent)) {
        // Set default renderer
        global.renderer.setDefault('flash');
    }


}());



/*jslint white: true, browser: true, windows: true, forin: true,  undef: true,

  plusplus: true, bitwise: true, regexp: true, immed: true */



/*global Array: false, FusionCharts, RegExp: false, jQuery: false, window: false,

  $: true, Highcharts: false, FusionChartsDataFormats: false, FC_Loaded, FC_DataLoaded, FC_Rendered, FC_DrawComplete */



/**

 * -----------------------------------------------------------------------------

 * HTML5 Renderer Module

 * -----------------------------------------------------------------------------

 */

(function () {

    var global, FCC = {}, baseURL = 'JSClass/', covertToFCC, renderArray = [],

    FCCready = false, i, scriptTags, jsConf = {};





    // Register the module with FusionCharts and als oget access to a global

    // variable within the core's scope.

    global = FusionCharts(['private', 'Canvas_Renderer']);

    // Check whether the module has been already registered. If true, then

    // do not bother to re-register.

    if (global === undefined) {

        return;

    }



    var FCCCREDITSTATE = false;



    //function that will return undefined

    //when any flash proparty has no effect in js chart

    //then add this methode reference for that property

    function noEffect() {

        return undefined;

    }



    

    //initialize Highcharts

    //this is the base function function to initialize javascript charts renderer





    FCC.init = function () {

        var passThroughStyle = function (name, suf, pref) {

                        return function (value, obj) {

                            obj.style[name] = (pref ? pref : '') + value + (suf ? suf : '');

                        };

                    },

        //variable to store various default values

        FCFCC = {

            color: ["AFD8F8", "F6BD0F", "8BBA00", "FF8E46", "008E8E", "D64646", "8E468E", "588526", "B3AA00", "008ED6", "9D080D", "A186BE", "CC6600", "FDC689", "ABA000", "F26D7D", "FFF200", "0054A6", "F7941C", "CC3300", "006600", "663300", "6DCFF6"],

            seriesName : {

                'Column2D' : 1,

                'Column3D' : 1,

                'Line' : 1,

                'Area2D' : 1,

                'Bar2D' : 1,

                'Pie2D' : 1,

                'Pie3D' : 1,

                'Doughnut2D' : 1,

                'Doughnut3D' : 1,

                'Pareto2D' : 1.5,

                'Pareto3D' : 1.5,

                'MSColumn2D' : 2,

                'MSColumn3D' : 2,

                'MSLine' : 2,

                'ZoomLine': 2.5,

                'MSBar2D' : 2,

                'MSBar3D' : 2,

                'MSArea' : 2,

                'InverseMSLine' : 2.2,

                'InverseMSColumn2D' : 2.2,

                'InverseMSArea' : 2.2,

                'StackedColumn3D' : 3,

                'Marimekko': 3,

                'StackedColumn2D' : 3,

                'StackedColumn2DLine': 3,

                'StackedColumn3DLine': 3,

                'StackedBar2D' : 3,

                'StackedBar3D' : 3,

                'StackedArea2D' : 3,

                'MSCombi3D' : 4,

                'MSCombi2D' : 4,

                'MSCombiDY2D' : 5,

                'MSColumnLine3D' : 4,

                'MSColumn3DLineDY' : 5,

                'MSStackedColumn2D' : 6,

                'MSStackedColumn2DLineDY' : 6.5,

                'StackedColumn3DLineDY' : 5.5,

                'Scatter' : 7,

                'Bubble' : 7.5,

                'ScrollColumn2D' : 2,

                'ScrollLine2D' : 2,

                'ScrollArea2D' : 2,

                'ScrollStackedColumn2D' : 3,

                'ScrollCombi2D' : 4,

                'ScrollCombiDY2D' : 5,

                'SSGrid' : 9,

                'Spline': 1,

                'SplineArea': 1,

                'MSSpline': 2,

                'MSSplineArea': 2,

                'MultiAxisLine': 8

            },

            highCharts : {

                'Column2D' : 'column',

                'Column3D' : 'column',

                'Line' : 'line',

                'Area2D' : 'area',

                'Bar2D' : 'bar',

                'Pie2D' : 'pie',

                'Pie3D' : 'pie',

                'Doughnut2D' : 'pie',

                'Doughnut3D' : 'pie',

                'Pareto2D' : 'column',

                'Pareto3D' : 'column',

                'MSColumn2D' : 'column',

                'MSColumn3D' : 'column',

                'MSLine' : 'line',

                'ZoomLine': 'line',

                'MSBar2D' : 'bar',

                'MSBar3D' : 'bar',

                'MSArea' : 'area',

                'InverseMSLine' : 'line',

                'InverseMSColumn2D' : 'column',

                'InverseMSArea' : 'area',

                'StackedColumn3D' : 'column',

                'StackedColumn2D' : 'column',

                'Marimekko': 'column',

                'StackedColumn2DLine': 'column',

                'StackedColumn3DLine': 'column',

                'StackedBar2D' : 'bar',

                'StackedBar3D' : 'bar',

                'StackedArea2D' : 'area',

                'MSCombi3D' : 'column',

                'MSCombi2D' : 'column',

                'MSCombiDY2D' : 'column',

                'MSColumnLine3D' : 'column',

                'MSColumn3DLineDY' : 'column',

                'MSStackedColumn2D' : '',

                'MSStackedColumn2DLineDY' : '',

                'StackedColumn3DLineDY' : 'column',

                'Scatter' : 'scatter',

                'Bubble' : 'scatter',

                'ScrollColumn2D' : 'column',

                'ScrollLine2D' : 'line',

                'ScrollArea2D' : 'area',

                'ScrollStackedColumn2D' : 'column',

                'ScrollCombi2D' : 'column',

                'ScrollCombiDY2D' : 'column',

                'SSGrid' : '',

                'Spline': 'spline',

                'SplineArea': 'areaspline',

                'MSSpline': 'spline',

                'MSSplineArea': 'areaspline',

                'MultiAxisLine': ''

            },

            combi : {

                'column2d' : 'column',

                'column3d' : 'column',

                'line' : 'line',

                'area' : 'area'

            },

            valueAbs: {

                'Pie2D' : true,

                'Pie3D' : true,

                'Doughnut2D' : true,

                'Doughnut3D' : true,

                'Marimekko' : true

            },

            exportFormat: {

                png: 'image/png',

                jpg: 'image/jpeg',

                pdf: 'application/pdf',

                svg: 'image/svg+xml'

            },

            JSONconf: {

                blankChart: {

                    chart: {

                        events: {},

                        margin: [0, 0, 0, 0]

                    },

                    credits: {

                        href: 'http://www.fusioncharts.com?BS=FCHSEvalMark',

                        text: 'FusionCharts - HighCharts',

                        enabled: FCCCREDITSTATE

                    },

                    legend: {

                        enabled: false

                    },

                    title: {

                        text: 'No data to display',  //default caption nodata to display

                        style: {

                            fontFamily: 'Verdana',

                            fontSize:  '10px',

                            color: '#666666'

                        }

                    },

                    plotOptions: {

                        series: {}

                    },

                    exporting: {

                        enabled: false

                    }

                }

            },

            commonMethodCSV: 'saveAsImage,print,exportChart,getXML,getChartAttribute,getDataAsCSV,hasRendered,signature,cancelExport',

            methodCSV: {

                'pie3d': ',togglePieSlice',

                'pie2d': ',togglePieSlice',

                'doughnut2D': ',togglePieSlice',

                'doughnut3D': ',togglePieSlice',

                'mscombi3d': ',view2D,view3D,resetView,rotateView,getViewAngles,fitToStage',

                'zoomline': ',zoomTo,setZoomMode,zoomOut,resetChart'

            },



            method: {

                getExternalInterfaceMethods: function (chartType) {

                    return FCFCC.commonMethodCSV +

                    (FCFCC.methodCSV[chartType || this.FusionCharts.chartType()] || '');

                },



                //print the chart

                print: function () {

                    var id = this.id;

                    FCC.items[id].FCCObj.FCC.print();

                },

                exportChart: function (conf) {//xeport the chart

                    var id = this.id, HCConf = {}, HCObj = FCC.items[id].FCCObj.FCC;

                    if (HCObj.options.exporting.enabled) {//check whether exporting is enabled or not

                        if (typeof conf === 'object') {

                            for (var x in conf) {

                                if (x.toLowerCase() === 'exportformat' && FCFCC.exportFormat[conf[x].toLowerCase()]) {

                                    HCConf.type = FCFCC.exportFormat[conf[x].toLowerCase()];

                                } else if (x.toLowerCase() === 'exportfilename') {

                                    HCConf.filename = conf[x];

                                }

                            }

                        }

                        HCObj.exportChart(HCConf);

                    }

                },

                getXML: function () {

                    var id = this.id;

                    return global.core.items[id].getXMLData();

                },

                //function to chech the signature /vertion

                signature : function () {

                    return 'FusionCharts/3.2.0/JS';

                },

                hasRendered: function () {

                    var id = this.id;

                    if (typeof FCC.items[id] === 'object') {

                        return true;

                    } else {

                        return false;

                    }

                },

                togglePieSlice: function (index) {

                    if (this.ref && this.ref.FCC && this.ref.FCC.series &&

                        this.ref.FCC.series[0] && this.ref.FCC.series[0].data &&

                        this.ref.FCC.series[0].data[index] &&

                        this.ref.FCC.series[0].data[index].slice()) {

                        //call the function

                        this.ref.FCC.series[0].data[index].slice();

                    }

                }

            },

            

            supportedStyle: {

                font: function (HC, toObj, style) {

                    var styleobject, x, map = {

                        font: passThroughStyle('font-family'),

                        size: passThroughStyle('font-size', 'px'),

                        color: passThroughStyle('color', undefined, '#'),

                        align: function (value, obj) {

                            obj.align = value;

                        },

                        bgColor: passThroughStyle('background-color', undefined, '#'),

                        borderColor: passThroughStyle('border-color', undefined, '#'),

                        isHTML: '',

                        leftMargin: passThroughStyle('margin-left', 'px'),

                        letterSpacing: passThroughStyle('letter-spacing', 'px'),

                        bold: function (value, obj) {

                            obj['font-weight'] = value == '1' ? 'bold' : 'normal';

                        },

                        italic: function (value, obj) {

                            obj['font-style'] = value == '1' ? 'italic' : 'normal';

                        },

                        underline: function (value, obj) {

                            obj['text-decoration'] = value == '1' ? 'underline' : 'normal';

                        }

                    };

                     

                    switch (toObj) {

                    case 'caption':

                        styleobject = HC.title;

                        break;



                    case 'datalabels':

                        styleobject = HC.xAxis.labels;

                        break;



                    case 'datavalues':

                        styleobject = HC.plotOptions.series.dataLabels;

                        break;



                    case 'subcaption':

                        styleobject = HC.subtitle;

                        break;



                    case 'tooltip':

                        styleobject = HC.tooltip;

                        break;



                    case 'trendvalues':

                        styleobject = undefined;

                        break;



                    case 'xaxisname':

                        styleobject = HC.xAxis.title;

                        break;



                    case 'yaxisname':

                        styleobject = HC.yAxis[0].title;

                        break;

                    case 'yaxisvalues':

                        styleobject = HC.yAxis[0].labels;

                        break;



                    default:

                        break;

                    }



                    if (typeof styleobject === 'object') {

                        for (x in style) {

                            if (typeof map[x] === 'function') {

                                map[x](style[x], styleobject);

                            }

                        }

                    }

                }

            }

        };



        var chartMessageStore = {};

        

        //clone an object's propaties in to another and marged

        function margeClone(obj1, obj2) {

            var item;

            if (typeof obj1 !== 'object' && typeof obj2 !== 'object') {//if none of the arguments are object then return back

                return null;

            }

            if (typeof obj1 !== 'object') {

                obj1 = {};

            }

            if (typeof obj2 !== 'object') {

                obj2 = obj1;

                obj1 = {};

            }

            //check whether obj2 is an array

            //if array then iterate through it's index

            //**** MOOTOOLS precution

            if (obj2 instanceof Array) {

                for (item = 0; item < obj2.length; item += 1) {

                    if (typeof obj2[item] !== 'object') {

                        obj1[item] = obj2[item];

                    } else {

                        obj1[item] = margeClone(obj1[item], obj2[item]);

                    }

                }

            }

            else {

                for (item in obj2) {

                    if (typeof obj2[item] !== 'object') {

                        obj1[item] = obj2[item];

                    } else {

                        obj1[item] = margeClone(obj1[item], obj2[item]);

                    }

                }

            }

            

            return obj1;

        }







        //Add the prototype for the FCC renderer

        //this contain all the methods which flash renderer add to the instance



        FCC.prototype = {

            

            // Add legacy setTransparent function



            setTransparent: function (transparency) {



                if (!this.jsVars) {

                    this.jsVars = {};

                }



                // Sets chart to transparent mode when isTransparent (wMode) is true

                // (default). When no parameter is passed, we assume transparent to

                // be true.

                if (typeof transparency !== 'boolean' && transparency !== null) {

                    transparency = true;

                }

                //set the tranparency flag

                this.jsVars.transparent = transparency;

                //using jquery set the background color of the container div

                if (typeof jQuery === 'function') {

                    jQuery('#' + this.id).css('background-color', (transparency === true) ? '' : '#FFFFFF');

                }



            },

            getSWFHTML: noEffect, //flash specific method

            

            //JS chart's function to pass a config. for js charts only

            _overrideJSChartConfiguration: function (conf) {

                //save the configuration of the chhart

                //which will be retrive during the chart creation

                jsConf[this.id] = conf;

            }



        };









        //set the baseURL

        //if user defined then use it

        if (global.core.options && global.core.options.scriptBaseUri !== undefined) {

            baseURL = global.core.options.scriptBaseUri;

        } else {//else use the baseURL FusionCharts.js

            scriptTags = document.getElementsByTagName('script');

            //iterate through all the script tag to fiend the path of the FC.JS file

            if (scriptTags) {

                for (i = 0; i < scriptTags.length; i += 1) {

                    if (scriptTags[i].src.indexOf('FusionCharts.js') !== -1) {

                        baseURL = scriptTags[i].src.split("FusionCharts.js")[0];

                    }

                }

            }

        }





        //Tha function to check whether the FCC is reday or not

        FCC.isReady = function () {

            return FCCready;

        };





        ///container for all FCC object with the base object[after convertion]

        // & chart object[FC ref.]

        FCC.items = {};







        //function  that will add a script tag in head

        function loadScript(src) {

            //create new script element

            //set the src

            //append in head

            var newele = document.createElement('script');

            newele.setAttribute('type', 'text/javascript');

            newele.setAttribute('src', src);

            var head = document.getElementsByTagName('head');

            head[0].appendChild(newele);

        }



        //function that will chaek whether FCC is ready or not



        function checkFCCReady() {

            var temp;

            if (typeof window.Highcharts === 'object') {

                FCCready = true;

                //call all the stacked render actions

                if (typeof FCC.render == 'function') {

                    while (renderArray.length > 0) {

                        temp = renderArray.splice(0, 1)[0];

                        FCC.render.call(temp[0], temp[1], temp[2]);

                    }

                }



            //call FCC onready function

            } else {

                setTimeout(checkFCCReady, 300);

            }

        }



        //load HIGFCCHARTS

        function loadFCC() {

            if (typeof jQuery === 'function') {

                jQuery.noConflict();

                //check whether there no one is using $ then please revert $ to it

                if ($ === undefined) {

                    $ = jQuery;

                }

                

                if (typeof window.Highcharts !== 'object') {

                    loadScript(baseURL + 'highcharts.js');

                    setTimeout(checkFCCReady, 300);

                } else {

                    checkFCCReady();

                }

            } else {

                setTimeout(loadFCC, 300);

            }

        }







        //load jquery

        if (typeof jQuery !== 'function') {

            loadScript(baseURL + 'jquery.min.js');

            setTimeout(loadFCC, 300);

        } else {

            loadFCC();

        }









        ////////// List of tools(functions) needed//////////



        //calculat axis max/min



        var getAxisLimits  = function (maxValue, minValue, yAxisMaxValue, yAxisMinValue, stopMaxAtZero, setMinAsZero) {



                var maxPowerOfTen, minPowerOfTen, powerOfTen, y_interval, rangePowerOfTen, rangeInterval, y_topBound, y_lowerBound, yMaxGiven, yMinGiven, yMax, yMin, range, interval;



                //First check if both maxValue and minValue are proper numbers.

                //Else, set defaults as 90,0

                maxValue = (typeof maxValue !== 'number') ? 0.1 : maxValue;

                minValue = (typeof minValue  !== 'number') ? 0 : minValue;

                //maxValue = (isNaN (maxValue) == true || maxValue == undefined) ? 0.1 : maxValue;

                //minValue = (isNaN (minValue) == true || minValue == undefined) ? 0 : minValue;





                //Or, if only 0 data is supplied

                if ((maxValue === minValue) && (maxValue === 0)) {

                    maxValue = 0.1;

                }



                //Defaults for stopMaxAtZero and setMinAsZero

                //stopMaxAtZero = getFirstValue (stopMaxAtZero, false);

                //setMinAsZero = getFirstValue (setMinAsZero, true);

                if (typeof stopMaxAtZero === 'undefined' || typeof stopMaxAtZero === 'null' || stopMaxAtZero === '') {

                    stopMaxAtZero = false;

                }

                if (typeof setMinAsZero === 'undefined' || typeof setMinAsZero === 'null' || setMinAsZero === '') {

                    setMinAsZero = true;

                }



                //Get the maximum power of 10 that is applicable to maxvalue

                //The Number = 10 to the power maxPowerOfTen + x (where x is another number)

                //For e.g., in 99 the maxPowerOfTen will be 1 = 10^1 + 89

                //And for 102, it will be 2 = 10^2 + 2

                maxPowerOfTen = Math.floor(Math.log(Math.abs(maxValue)) / Math.LN10);

                //Get the minimum power of 10 that is applicable to maxvalue

                minPowerOfTen = Math.floor(Math.log(Math.abs(minValue)) / Math.LN10);



                //Find which powerOfTen (the max power or the min power) is bigger

                //It is this which will be multiplied to get the y-interval

                powerOfTen = Math.max(minPowerOfTen, maxPowerOfTen);

                y_interval = Math.pow(10, powerOfTen);



                //For accomodating smaller range values (so that scale doesn't represent too large an interval

                if (Math.abs(maxValue) / y_interval < 2 && Math.abs(minValue) / y_interval < 2) {

                    powerOfTen -= 1;

                    y_interval = Math.pow(10, powerOfTen);

                }



                //If the y_interval of min and max is way more than that of range.

                //We need to reset the y-interval as per range

                rangePowerOfTen = Math.floor(Math.log(maxValue - minValue) / Math.LN10);

                rangeInterval = Math.pow(10, rangePowerOfTen);

                //Now, if rangeInterval is 10 times less than y_interval, we need to re-set

                //the limits, as the range is too less to adjust the axis for max,min.

                //We do this only if range is greater than 0 (in case of 1 data on chart).

                if (((maxValue - minValue) > 0) && ((y_interval / rangeInterval) >= 10)) {

                    y_interval = rangeInterval;

                    powerOfTen = rangePowerOfTen;

                }

                //Calculate the y-axis upper limit

                y_topBound = (Math.floor(maxValue / y_interval) + 1) * y_interval;

                //Calculate the y-axis lower limit

                //y_lowerBound

                //If the min value is less than 0

                if (minValue < 0) {

                    //Then calculate by multiplying negative numbers with y-axis interval

                    y_lowerBound = - 1 * ((Math.floor(Math.abs(minValue / y_interval)) + 1) * y_interval);

                } else {

                    //Else, simply set it to 0.

                    if (setMinAsZero) {

                        y_lowerBound = 0;

                    } else {

                        y_lowerBound = Math.floor(Math.abs(minValue / y_interval) - 1) * y_interval;

                        //Now, if minValue>=0, we keep x_lowerBound to 0 - as for values like minValue 2

                        //lower bound goes negative, which is not required.

                        y_lowerBound = (y_lowerBound < 0) ? 0 : y_lowerBound;



                    }

                }

                //MaxValue cannot be less than 0 if stopMaxAtZero is set to true

                if (stopMaxAtZero && maxValue <= 0) {

                    y_topBound = 0;

                }



                //Now, we need to make a check as to whether the user has provided an upper limit

                //and lower limit.

                if (yAxisMaxValue === null || yAxisMaxValue === undefined || yAxisMaxValue === "") {

                    yMaxGiven = false;

                } else {

                    yMaxGiven = true;

                }

                if (yAxisMinValue === null || yAxisMinValue === undefined || yAxisMinValue === "" || typeof Number(yAxisMinValue) === 'NaN') {

                    yMinGiven = false;

                } else {

                    yMinGiven = true;

                }

                //If he has provided it and it is valid, we leave it as the upper limit

                //Else, we enforced the value calculate by us as the upper limit.

                if (yMaxGiven === false || (yMaxGiven === true && Number(yAxisMaxValue) < maxValue)) {

                    yMax = y_topBound;

                } else {

                    yMax = Number(yAxisMaxValue);

                }

                //Now, we do the same for y-axis lower limit

                if (yMinGiven === false || (yMinGiven === true && Number(yAxisMinValue) > minValue)) {

                    yMin = y_lowerBound;

                } else {

                    yMin = Number(yAxisMinValue);

                }

                //Store axis range

                range = Math.abs(yMax - yMin);

                //Store interval

                interval = y_interval;



                return {Max: yMax, Min: yMin, Range: range, interval: interval};

            };









        //function to create thecontainer element for chart

        function createContainer(contanerId, chartId, width, height, cleanCopy) {

            //get the container

            var container = document.getElementById(chartId), __container = document.getElementById(contanerId),

            /**

             * @var {RegExp} lengthPercentageRegExp determines whether a string has

             * trailing percentage character or not. Ignoring white-spaces.

             */

            lengthPercentageRegExp = /\%\s*?$/ig;

            ////

            //check whether there needs an clean div

            if (cleanCopy === true) {

                ///delete the span created by FC.js

                if (container) {

                    __container.removeChild(container);

                }

                //create a div as per chart id

                // set the height and width and relative position for the back button

                //set the background white for transparency 0

                container = document.createElement('div');

                container.setAttribute('id', chartId);

                __container.appendChild(container);

            }

            //add all attributes

            for (var x in this.attributes) {

                container[x] = this.attributes[x];

            }

            //add the className fix for IE

            if (this.attributes['class']) {

                container.className = this.attributes['class'];

            }

            container.setAttribute('style', 'display: inline-block; zoom: 1; *display: inline;');

            ////check whether width and hight are string

            //otherwise don't math the reg just add px

            container.style.width = width + (width.match(lengthPercentageRegExp) ? '' : 'px');

            container.style.height = height + (height.match(lengthPercentageRegExp) ? '' : 'px');

        }



        //function that will remove a chart

        function removeChart(id, deleteDom) {

            //destroy the HC obj from HC methode

            if (FCC.items[id]) {

                if (FCC.items[id].FCCObj && FCC.items[id].FCCObj.FCC) {

                    FCC.items[id].FCCObj.FCC.destroy();

                }

                //cleare the mimer for resize chart event

                clearTimeout(FCC.items[id].timeChach);

               

                //remove the div element if requred

                if (deleteDom === true) {

                    // @var refObj {HTMLNode} Create reference to the chart object.

                    var refObj = FCC.items[id].FCCObj;



                    // Check whether HTML Node reference exist or not. If it exists,

                    // climb up to its parent node in DOM and delete the element.

                    if (refObj && refObj.parentNode) {

                        refObj.parentNode.removeChild(refObj);

                    }

                }

                //delete the HC obj from local store

                delete FCC.items[id];

            }

        }



        ///function to create bank serease

        function createSeries(FCtype, color, type, name, yAxis, showvalue, linecolor, linethickness, marker) {

            return {

                data: [],

                FCtype: FCtype,

                color: color,

                type: type,

                name: name ? name: ' ',

                yAxis: yAxis ? 1: undefined,

                showvalue: showvalue,

                lineColor: linecolor,

                lineWidth : linethickness,

                marker: marker

            };

        }



        //parse a string as per configuration

        function parseStr(str) {

            if (typeof str === 'string') {

                return str.replace(/\{br\}/ig, '<br/>');

            }

            else {

                return '';

            }

        }

        /////function that will create a hc object to show a message

        function createMsg(id, msgTxt, event) {

            //coppy the blank chart object

            var HCJson = FCFCC.JSONconf.blankChart;

            //set the title y pos. for the chart so that the msg get into the cender

            HCJson.title.y = parseInt(document.getElementById(id).offsetHeight, 10) / 2;

            //set the renderTo id

            HCJson.chart.renderTo = id;

            ////set the chart message

            HCJson.title.text = chartMessageStore[id][msgTxt] ? chartMessageStore[id][msgTxt] : msgTxt;

            //raise the nodata event

            if (typeof event === 'string') {

                global.raiseEvent(event, {}, global.core.items[id]);

            }

            return HCJson;

        }





        //function that will show a message in achart

        function showChartMessage(msg) {

            var id = this.id, HCJson, FC = global.core.items[id];

            //check wheteher the container exist

            //==> false if a linked chart is opened

            if (FC.ref) {

                //save the chart message

                chartMessageStore[id].msgTxt = msg;

                //destroy the old HC chart

                FC.ref.FCC.destroy();

                //create new HC json to show the chart

                HCJson = createMsg(id, 'msgTxt', undefined);

                

                //create the ref of new high charts

                FC.ref.FCC = new Highcharts.Chart(HCJson);

                

                //save the chart's various objects in local store

                FCC.items[id].baseObj =  HCJson;

            }

            

            if (FC.link.root === FC) {//check whether it is not an linked chart

                return;

            }

            //if linked chart show the back button

            var config = global.extend({

                show: true

            }, this.FusionCharts.link.parent.options.overlayButton);

            global.extend(config, this.FusionCharts.link.parent.link.configuration().overlayButton || {});



            this.drawOverlayButton(config);

        }



        //function that will draw a overlay button

        function drawOverlayButton(conf) {

            if (conf.show) {//if have to show the overlay button

                //createw a span for back button

                //add the text

                //set border color onclick function etc.

                var back = document.createElement('span');

                back.innerHTML = conf.message ? conf.message : "Back";

                back.style.border = '1px solid #' + (conf.borderColor ? conf.borderColor : "7f8975");

                back.style.backgroundColor = '#' + (conf.bgColor ? conf.bgColor : "edefec");

                back.style.fontFamily = conf.font ? conf.font : "Verdana";

                back.style.color = '#' + conf.fontColor ? conf.fontColor:"49563a";

                back.style.fontSize = (conf.fontSize ? conf.fontSize : '10') + 'px';

                back.style.padding = (conf.padding ? conf.padding : '3') + 'px';

                back.style.fontWeight = parseInt(conf.bold, 10) === 0 ? 'normal' : 'bold';

                back.style.position = 'absolute';

                back.style.top = '1px';

                back.style.right = '1px';

                back.style._cursor = 'hand';

                back.style.cursor = 'pointer';

                back.onclick = (function (sender) {

                    return function () {

                        global.raiseEvent('OverlayButtonClick', {}, sender.FusionCharts);

                    };

                }(this));

                document.getElementById(this.id).childNodes[0].appendChild(back);

            }

        }





        //this functon will map chart series type with its name  and return it

        function getSeriesName(chartName) {

            return FCFCC.seriesName[chartName];

        }



        //reduce gradent color take only first color

        //converts color to compatable color format

        //**** rgba must be rgbs(r,g,b,a) format

        function convertColor(color, alpha, rgba) {

            var R = 0, G = 0, B = 0, colorStr, tempArr;

            

            

            if (rgba && rgba.match(/^rgba/ig)) {

                tempArr = rgba.split(',');

                R = tempArr[0].slice(tempArr[3].indexOf('(') + 1);

                G = tempArr[1];

                B = tempArr[2];

                if (!alpha) {

                    alpha = parseInt(tempArr[3].slice(0, tempArr[3].indexOf(')')), 10) * 100;

                }

            }

            if (color) {

                colorStr = color.replace(/[#\s]/ig, '').split(',')[0];

                switch (colorStr.length) {

                case 3:

                    colorStr = colorStr[0] + colorStr[0] + colorStr[1] + colorStr[1] + colorStr[2] + colorStr[2];

                    break;

                case 6:

                    break;

                default:

                    colorStr = (colorStr + 'FFFFFF').slice(0, 6);

                    break;

                }

                R = parseInt(colorStr.slice(0, 2), 16);

                G = parseInt(colorStr.slice(2, 4), 16);

                B = parseInt(colorStr.slice(4, 6), 16);

            }

            

            if (!alpha) {

                alpha = 100;

            }

            if (typeof alpha === 'string') {

                alpha = alpha.split(',')[0];

            }

            alpha = parseInt(alpha, 10) / 100;

            return 'rgba(' + R + ',' + G + ',' + B + ',' + alpha + ')';

        }





        ///get The Gradient Point

        var getCordinate = function (x, y, width, height, angle) {

            x = x ? x : 0;

            y = y ? y : 0;

            width = (typeof width !== 'undefined') ? width : 400;

            height = (typeof height !== 'undefined') ? height : 400;

            angle = (typeof angle !== 'undefined') ? angle : 0;



            var x1, x2, y1, y2, tan, temp;

            

            tan = Math.tan((angle * Math.PI) / 180);

            y1 = Math.round(height / 2 - ((width / 2) * tan));

            x1 = Math.round(width / 2 - ((height / 2) / tan));

            x1 = (x1 < 0) ? 0 : x1;

            x1 = (x1 > width) ? width : x1;

            y1 = (y1 < 0) ? 0 : y1;

            y1 = (y1 > height) ? height : y1;

            x2 = width - x1;

            y2 = height - y1;

            if (angle > 90 && angle <= 270) {

                temp = y1;

                y1 = y2;

                y2 = temp;

            }

            if (angle > 180 && angle <= 360) {

                temp = x1;

                x1 = x2;

                x2 = temp;

            }

            return [x1 + x, y1 + y, x2 + x, y2 + y];

        };





        ///Create The Color Stop

        var fillGcolorPoint = function (bgColor, bgAlpha, bgRatio) {

            var x, first, count = 0, blendAt, rgb, alpha, colorStop = [];

            bgAlpha = bgAlpha ? bgAlpha.split(",") : undefined;

            bgRatio = bgRatio ? bgRatio.split(",") : undefined;

            bgColor = bgColor.split(",");



            first = (typeof bgRatio === 'object') ? bgRatio[0] : undefined;



            for (x = 0; x < bgColor.length; x += 1) {

                rgb = bgColor[x];

                blendAt = bgRatio ? bgRatio[x] : undefined;

                alpha = bgAlpha ? bgAlpha[x] :100;

                alpha = alpha ? alpha : 100;



                if (!blendAt) {//blendAt is undefined

                    first = 1;

                    blendAt = (x !== 0) ? ((100 - count) / (bgColor.length - x)) : 0;

                }

                if (first) {

                    count += parseInt(blendAt, 10);

                }

                else {

                    count = parseInt(blendAt, 10);

                }

                if (count >= 100) {

                    colorStop.push([1, convertColor(rgb, alpha)]);

                    break;

                }

                else {

                    colorStop.push([count / 100, convertColor(rgb, alpha)]);

                }

            }

            return colorStop;

        };





        ////////Main Function To Create Color

        var CreateColor = function (x, y, width, height, angle, bgColor, bgAlpha, bgRatio) {

            var colorObj = {};



            ///Fiend The Gradient Point

            colorObj.linearGradient = getCordinate(x, y, width, height, angle);

            //set the coloe stops

            colorObj.stops = fillGcolorPoint(bgColor, bgAlpha, bgRatio);

            if ('\v' === 'v') {

                if (2 * colorObj.linearGradient[0] > width) {

                    colorObj.stops.reverse();

                    for (var i = 0; i < colorObj.stops.length; i += 1) {

                        colorObj.stops[i][0] = 1 - colorObj.stops[i][0];

                    }

                }

                //set 1 stop for IE if not exist

                if (colorObj.stops[colorObj.stops.length - 1][0] !== 1) {

                    colorObj.stops.push([1, colorObj.stops[colorObj.stops.length - 1][1]]);

                }

                //set 0 stop for IE if not exist

                if (colorObj.stops[0][0] !== 0) {

                    colorObj.stops.splice(0, 0, [0, colorObj.stops[0][1]]);

                }

            }

            return colorObj;

        };



        //this function will map FC name to FCC name and return the corosponding FCC name

        var convertNames = function (chartName) {

            return FCFCC.highCharts[chartName];

        };





        //this function will datsa to parcentage of total for pareto line

        var paretoConvert = function (data) {

            var x, psum = 0, pareto = {

                yAxis: 1,

                data: [],

                type: 'line',

                color: 'rgba(00,00,00,1)',

                FCtype: 1.5

            }, sum = 0;

            if (data instanceof Array) {

                for (x = 0; x < data.length; x += 1) {

                    sum += data[x].y;

                }

                for (x = 0; x < data.length; x += 1) {

                    psum += data[x].y;

                    pareto.data.push({

                        y : Math.round((psum / sum) * 10000) / 100

                    });

                }

            }

            return pareto;

        };



        //return the name of the chart swf file from it's src'

        //e.g. charts/Column2D.swf will return Column2D



        var convertSWFtoAlias = function (swf) {

            var alias = swf.substring(swf.indexOf('.swf'), 0);

            return alias.substring(alias.lastIndexOf('/') + 1);

        };





        var formatNumber = function (num, obj, type) {

            // If type is undefined initialize type with 1

            type = type === undefined ? 1 : type;

            /* if (typeof num == 'string') {

                num = parseFloat(num);

            }*/



            // Defines FusionCharts default values and attributes

            var chart = {

                formatnumber: 1,

                formatnumberscale: 1,

                defaultnumberscale: '',

                numberscaleunit: 'K,M',

                numberscalevalue: '1000,1000',

                numberprefix: "",

                numbersuffix: "",

                decimalseparator: ".",

                thousandseparator: ",",

                indecimalseparator: "",

                inthousandseparator: "",

                decimals: "",

                forcedecimals: "0",

                yaxisvaluedecimals: "",

                sformatnumber: "1",

                sformatnumberscale: "0",

                sdefaultnumberscale: "",

                snumberscaleunit: "K,M",

                snumberscalevalue: "1000,1000",

                snumberprefix: "",

                snumbersuffix: "",

                sdecimals: "",

                sforcedecimals: "0",

                syaxisvaluedecimals: "0"

            };



            var numberScaleValue, numberScaleUnit, result, i, res, power, 

                formatedNum = '', c = 0, initialVal, decimalVal, splitVal,

                decimalLength, last;



            // Replace default attributes with new attributes

            for (i in obj) {

                chart[i.toLowerCase()] = obj[i];

            }

          



            // Replace the indecimalseparator value with decimal to perform numeric operations

            num = chart.indecimalseparator !== '' ? 

                num.toString().replace(chart.indecimalseparator, '.') : num;



            // Replace the inthousandseparator value with decimal to perform numeric operations

            num = chart.inthousandseparator !== '' ? 

                num.toString().replace(chart.inthousandseparator, '') : num;



            if (type !== 1) {

                chart.formatnumber = chart.sformatnumber;

                chart.formatnumberscale = chart.sformatnumberscale;

                chart.defaultnumberscale = chart.sdefaultnumberscale;

                chart.numberscaleunit = chart.snumberscaleunit;

                chart.numberscalevalue = chart.snumberscalevalue;

                chart.numberprefix = chart.snumberprefix;

                chart.numbersuffix = chart.snumbersuffix;

                chart.decimals = chart.sdecimals;

                chart.forcedecimals = chart.sforcedecimals;

                chart.yaxisvaluedecimals = chart.syaxisvaluedecimals;

            }



            // Creates array of numberScaleValue and numberScaleUnit to format the number

            numberScaleValue = chart.numberscalevalue.split(',');

            numberScaleUnit = chart.numberscaleunit.split(',');



            result = res = num.toString();



            // format the number with,

            if (chart.formatnumber == 1) {

                if (res.indexOf('.') !== -1) {

                    splitVal = res.split('.');

                    initialVal = splitVal[0];

                    decimalVal = '.' + splitVal[1];

                }

                else {

                    initialVal = res;

                    decimalVal = '';

                }

                for (i = initialVal.length; i > 0; i -= 1) {

                    if (c % 3 === 0 && c !== 0) {

                        formatedNum = chart.thousandseparator + formatedNum;

                        c = 0;

                

                    }

                    //formatedNum = res[i - 1] + formatedNum;

                    formatedNum = res.charAt(i - 1) + formatedNum;

                    c += 1;

                }



                



                result = (splitVal === undefined) || (decimalVal === 0) ? formatedNum : formatedNum + decimalVal;

            }



            // Places K, M, B number format

            if (chart.formatnumberscale == 1) {

                res = num;

                for (i = 0; i < numberScaleValue.length && res / numberScaleValue[i] >= 1; i += 1) {

                    res = res / numberScaleValue[i];

                }

                i -= 1;



                if (chart.decimals === '') {

                    chart.decimals = '2';

                }

                power = Math.pow(10, chart.decimals);

                result = (i === -1) ? Math.round(res * power) / power :

                    Math.round(res * power) / power;

            }



            // force decimal is true

            if (chart.forcedecimals == 1) {

                // checkes wather the result number is in decimal or not

                if (result.toString().indexOf(chart.decimalseparator) !== -1) {

                    decimalVal = result.toString().split(chart.decimalseparator)[1];

                    decimalLength = decimalVal.length;

                }

                else {

                    decimalLength = 0;

                }

                if (decimalLength === 0) {

                    result += chart.decimalseparator;

                }

                if (decimalLength > chart.decimals) {

                    if (chart.decimals == 1 && decimalVal[0] >= 5) {

                        last = result[result.substring(0, result.indexOf('.')).length - 1];

                        last += 1;

                        result = result.substring(0, (result.indexOf('.') - 1)) + last;

                        result = result + '.' + '0';

                    }

                    else if (decimalVal[chart.decimals - 1] >= 5) {

                        last = decimalVal[chart.decimals] >= 5 ? 

                            (parseInt(decimalVal[chart.decimals - 1], 10) + 1) :

                            decimalVal[chart.decimals - 1];

                        decimalVal = decimalVal.substring(0, chart.decimals - 1) +

                            last;

                        result = result.substring(0, result.indexOf('.')) + '.' +

                            decimalVal;

                    }

                }

                else {

                    while (decimalLength < chart.decimals) {

                        result += '0';

                        decimalLength += 1;

                    }

                }

            }



            if (chart.formatnumberscale == 1) {

                result += (i === -1) ?

                    chart.defaultnumberscale : numberScaleUnit[i];

            }



            result = chart.numberprefix + result + chart.numbersuffix;



            if (chart.decimalseparator !== "." && chart.decimalseparator !== "") {

                result = result.toString().replace('.', chart.decimalseparator);

            }

            return result;

        };



        //map FusionCharts anchor sides to HC anchor symbol

        //anchorside > 4 will show the down triangle

        var convertAncorSide = function (num) {

            var x = 'circle';

            switch (num) {

            case 3:

                x = 'triangle';

                break;

            case 4:

                x = 'diamond';

                break;

            default:

                x = 'square';

                break;

            }

            if (isNaN(num)) {

                x = 'circle';

            }



            return x;

        };





        var newwindow;///variable for popup

        ///this function will open a link



        var pointClick = function (flag, unescape) {



            var link = '', arr, chartId, sender;

            if ((flag === 2 && this.link) ||

                (flag === 1 && this.options.chart.link)) {



                if (flag === 2 && this.link) {

                    link = unescape == '0' ?

                        this.link : window.decodeURIComponent(this.link);

                    link.replace(/^[\s]*/, '');

                    arr = this.link.split('-');

                    chartId = this.options.id;

                    sender = global.core.items[chartId];

                }



                else if (flag === 1 && this.options.chart.link) {

                    link = unescape == '0' ?

                        this.options.chart.link : window.decodeURIComponent(this.options.chart.link);

                    link.replace(/^[ ]*/, '');

                    arr = this.options.chart.link.split('-');

                    chartId = this.options.chart.renderTo;

                    sender = global.core.items[chartId];

                }

                switch (arr[0].toLowerCase()) {

                case 'n':

                    window.open(arr[1]);

                    break;

                case 'f':

                    if (frames[arr[1]]) {

                        frames[arr[1]].location = arr[2];

                    }

                    else {

                        window.open(arr[2], arr[1]);

                    }

                    break;

                case 'j':

                    try {

                        window[arr[1]](arr[2]);

                    }

                    catch (er) {



                    }

                    break;

                case 'p':

                    newwindow = window.open(arr[2], arr[1].match(/[^,]+/i),

                        arr[1].replace(/[^,]+,/i, ''));

                    if (window.focus) {

                        newwindow.focus();

                    }

                    break;

                case 'newchart':

                    var linkType = arr[1].toLowerCase().search('url') != -1 ?

                        'URL' : FusionChartsDataFormats.JSON, data, x, chartJson, linkchartId;



                    if (linkType === 'URL') {

                        data = link.replace(/[^\-]+-[^\-]+-/i, '');

                    }



                    else {

                        chartJson = global.core.items[chartId].getChartData(FusionChartsDataFormats.JSON);

                        linkchartId = link.replace(/[^\-]+-[^\-]+-/i, '');

                        if (chartJson.linkeddata) {

                            for (x = 0; x < chartJson.linkeddata.length; x += 1) {

                                if (chartJson.linkeddata[x].id == linkchartId) {

                                    data = chartJson.linkeddata[x].linkedchart;

                                }

                            }

                        }

                    }

                    global.raiseEvent('LinkedChartInvoked', {

                        linkType : linkType,

                        data : data

                    }, sender);

                    break;

                default:

                    arr = link.split(':');

                    if (arr[0].toLowerCase() == 'javascript') {

                        try {

                            eval(arr[1]);

                        } catch (err) { }

                    }

                    else {

                        window.location.href = link;

                    }

                    break;

                }

            }

        };





        ///fiend the max z value among all the data

        var maxZVal = function (obj) {

            var max = 0, x, y, temp;

            if (obj instanceof Array) {

                for (x = 0; x < obj.length; x += 1) {

                    if (obj[x].data instanceof Array) {

                        for (y = 0; y < obj[x].data.length; y += 1) {

                            temp =  parseInt(obj[x].data[y].z, 10);

                            max = (max > temp) ? max : temp;

                        }

                    }

                }

            }

            return max;

        };



        ///function to determine max redious for buble chart depending on the chart width and height

        var maxRedious = function (width, height) {

            var lower, max = 5;

            lower = (width > height) ? height : width;

            if (lower > 100) {

                max = lower / 8;

            }

            return max;

        };



        ///function that will create a HCJSON

        var createHCJson = function (__containerId, cleanCopy) {

            var width = this.width, height = this.height,

                chart = convertSWFtoAlias(this.src), id = this.id,

                jsonObj, container, dataComp, HCJson;



            //destroy the old chart

            removeChart(id, cleanCopy);



            //create container

            createContainer.call(this, __containerId, id, width, height, cleanCopy);



            //get the chart data

            dataComp = this.getChartData(FusionChartsDataFormats.JSON, true);

            jsonObj = dataComp.data;



            //chart not supported

            if (!FCFCC.highCharts[chart]) {

                HCJson = createMsg(id, 'ChartNotSupported', 'featurenotsupported');

            }

            ////if chart has any msg to show

            else if (chartMessageStore[id].msgTxt) {

                HCJson = createMsg(id, 'msgTxt', undefined);

            }

            ////if chart has data loading error

            else if (this.jsVars && this.jsVars.LoadError) {

                HCJson = createMsg(id, 'LoadDataErrorText', undefined);

            }

            ////if chart is retriving data

            else if (this.jsVars && this.jsVars.stallLoad) {

                HCJson = createMsg(id, 'XMLLoadingText', undefined);

            }

            ////if chart will show xml parse error

            else if (dataComp.error instanceof Error) {

                HCJson = createMsg(id, 'InvalidXMLText', 'nodatatodisplay');

            }

            //convert the chart's JSON into HC compatable data

            else {

                //get the container

                container = document.getElementById(id);

                //convart it into FCC data

                HCJson = covertToFCC(id, chart, jsonObj, id, container.offsetWidth,

                    container.offsetHeight);

                

                //if no data to display

                if (HCJson.series.length === 0) {

                    HCJson = createMsg(id, 'NoDataText', 'nodatatodisplay');

                }



            }

            //return the HC object

            return HCJson;



        };



        ///add the event listner to add the chart specific functions

        var addEIMethods = function (ref, obj) {



            // Process these events only for objects that have flash renderer!

            if (obj.options.renderer !== 'javascript') {

                return;

            }



            // The externalInterfaceMethods names are parsed from CSV to

            // Array.

            var eiItems = FCFCC.method.getExternalInterfaceMethods(obj.chartType()).split(','), i;



            // We iterate through all the externalInterface method names and

            // create an extensible API object that is added to main

            // FusionCharts object as reference.

            for (i = 0; i < eiItems.length; i += 1) {



                if (typeof ref[eiItems[i]] === 'function') {

                    continue;

                }



                if (FCFCC.method[eiItems[i]] === undefined) {

                    ref[eiItems[i]] = noEffect;

                }

                else {

                    ref[eiItems[i]] = FCFCC.method[eiItems[i]];

                }

            }

        };



          ////////function that will create the chart

        ///this will represent the Fusionchart object

        function createChart(callBack, HCJson) {

            var chart = convertSWFtoAlias(this.src), id = this.id;



            //set the trancparency

            if (!(this.jsVars && this.jsVars.transparent)) {

                jQuery('#' + this.id).css('background-color', '#FFFFFF');

            }



            //create the ref

            var ref = document.getElementById(id);



            ref.drawOverlayButton =  drawOverlayButton;

            ref.showChartMessage = showChartMessage;

            ref.getExternalInterfaceMethods = FCFCC.method.getExternalInterfaceMethods;

            addEIMethods(ref, this);



            //call the call back function

            if (typeof callBack === 'function') {

                try {

                    callBack({

                        success: true,

                        ref: ref,

                        id: id

                    });

                }catch (err) {

                }

            }



            ref.FCC = new Highcharts.Chart(HCJson);



            //arrange vlines & trendlines trendZones etc.

            var verticalPlotElements = jQuery('.highcharts-grid')[0];

            var horizontalPlotElements = jQuery('.highcharts-grid')[1];

            if (verticalPlotElements && horizontalPlotElements) {

                verticalPlotElements.parentNode.insertBefore(horizontalPlotElements, verticalPlotElements);

            }

            //save the chart's various objects in local store

            FCC.items[id] = {

                'baseObj': HCJson,

                'FCCObj': ref,

                'chartType': chart

            };





        }

        



        //function that will be called on window resize if there has a size difference occure

        var onWindowResize = function (FCCChart, id) {

            var FCObj;

            //Clear the timer for the previous prevoius frequent resize function

            clearTimeout(FCCChart.timeChach);

            //FusionCharts OBJECT

            FCObj = global.core.items[id];

            //render the chart after 500 ms

            FCCChart.timeChach = setTimeout((function (FCObj) {

                return function () {

                    var id = FCObj.id, __containerId = FCObj.options.containerElementId, HCJson;

                    // check whether chart already rendered and update the data

                    if (typeof __containerId !== 'undefined' &&

                        typeof FCC.items[id] !== 'undefined') {

                        //create the HC json

                        HCJson = createHCJson.call(FCObj, __containerId);

                        //add the load event

                        HCJson.chart.events.load = function () {

                            global.raiseEvent('loaded', {}, FCObj);

                            global.raiseEvent('resized', {}, FCObj);

                        };

                        //stop the animation

                        HCJson.plotOptions.series.animation = false;



                        //render the new chart

                        createChart.call(FCObj, undefined, HCJson);



                    }

                };

            }(FCObj)), 500);

        };





        //function that will call if the window resize ocured

        var FCCresize = function () {



            var FCCChart, FCCContainer, id;

            //iterate through all FusionCharts Html5 Items From Store

            for (var x in FCC.items) {   ///it's alwayes an object

                id = x;

                //take the in a local a vriable

                FCCChart = FCC.items[x];

                //get the container Element of the chart

                FCCContainer = document.getElementById(x);



                //Check whether the size of the container has Changed

                //container will be null if the chart has invocked a linked chart

                if (FCCContainer &&

                    (FCCContainer.offsetWidth != FCCChart.FCCObj.FCC.chartWidth ||

                        FCCContainer.offsetHeight != FCCChart.FCCObj.FCC.chartHeight)) {

                    onWindowResize(FCCChart, id);

                }

            }

        };







        ///add the resize event



        if (window.addEventListener) {//for nonIE

            window.addEventListener("resize", FCCresize, false);

        }

        else if (window.attachEvent) {//for IE

            window.attachEvent("onresize", FCCresize);

        }

        else {//older browser

            window.onresize = FCCresize;

        }





        ////////////////  Working Functions /////////////////////



        //this function will create a default FCC object

        //

        var newFCCstub = function (cObj) {

            return {

                FCconf: {

                    negative: false,//for inverse chart whether there has any negative value or not

                    stackValue: []

                },

                chart: {

                    alignTicks: false,

                    renderTo: '',

                    ignoreHiddenSeries: false,

                    events: {

                        click: function () {

                            pointClick.call(this, 1, cObj.chart.unescapelinks);

                        }

                    },

                    margin: [15, 15, 50, 60],

                    borderRadius: 0,

                    plotBackgroundColor : '#FFFFFF'

                },

                colors: [],

                credits: {

                    href: 'http://www.fusioncharts.com?BS=FCHSEvalMark',

                    text: 'FusionCharts - HighCharts',

                    enabled: FCCCREDITSTATE

                },

                global: {},

                labels: {

                    items: []

                },

                lang: {},

                legend: {

                    enabled : true,

                    symbolWidth: 5,

                    borderRadius: 0,

                    itemStyle: {}

                },

                loading: {},

                plotOptions: {

                    series: {

                        borderColor : '#333333',

                        events: {},

                        dataLabels : {

                            enabled : true,

                            color: '#555555',

                            style: {},

                            formatter : function () {

                                var x, y, showvalue = this.point.options.showvalue ||

                                    this.series.options.showvalue ||

                                    this.series.chart.options.chart.showvalue;

                                if (this.series.type == 'pie') {

                                    x = (cObj.chart.showlabels === '0' || !this.point.FCname ? '' : this.point.FCname);

                                    y = showvalue === '1' ? (Math.round(this.percentage * 100) / 100) + (cObj.chart.showpercentagevalues === '1' ? '%' : ''): '';

                                    

                                    return parseStr(x + (x !== '' && y !== '' ? cObj.chart.tooltipsepchar : '') + y);

                                }

                                else if (showvalue === '1') {

                                    if (this.point.options.displayvalue) {

                                        x = this.point.options.displayvalue;

                                    } else {

                                        x = formatNumber(this.y, cObj.chart, 1);

                                        if (this.series.options.FCtype == 1.5 && this.series.type == 'line') {

                                            x = this.y + '%';

                                        }

                                        if (this.series.options.FCtype == 7.5) {

                                            x = '';

                                        }

                                    }

                                    return parseStr(x);

                                } else {

                                    return '';

                                }

                            }

                        },

                        point: {

                            events: {

                                click:  function () {

                                    pointClick.call(this, 2, cObj.chart.unescapelinks);

                                }

                            }

                        }

                    },

                    area: {

                        states: {

                            hover: {

                                enabled: false

                            }

                        },

                        marker: {

                            lineWidth: 1,

                            radius: 3,

                            states: {

                                hover: {

                                    enabled: false

                                },

                                select: {

                                    enabled: false

                                }

                            }

                        }

                    },

                    areaspline: {

                        states: {

                            hover: {

                                enabled: false

                            }

                        },

                        marker: {

                            lineWidth: 1,

                            radius: 3,

                            states: {

                                hover: {

                                    enabled: false

                                },

                                select: {

                                    enabled: false

                                }

                            }

                        }

                    },

                    line: {

                        states: {

                            hover: {

                                enabled: false

                            }

                        },

                        marker: {

                            lineWidth: 1,

                            radius: 3,

                            states: {

                                hover: {

                                    enabled: false

                                },

                                select: {

                                    enabled: false

                                }

                            }

                        }

                    },

                    spline: {

                        states: {

                            hover: {

                                enabled: false

                            }

                        },

                        marker: {

                            lineWidth: 1,

                            radius: 3,

                            states: {

                                hover: {

                                    enabled: false

                                },

                                select: {

                                    enabled: false

                                }

                            }

                        }

                    },

                    pie: {

                        size: '80%',

                        allowPointSelect: true,

                        cursor: 'pointer'

                    },

                    column: {}

                },

                point: {},

                series: [{}],

                subtitle: {

                    text: '',

                    style : {}

                },

                symbols: [],

                title: {

                    text : '',

                    style : {}

                },

                toolbar: {},

                tooltip: {

                    borderRadius: 0,

                    style: {},

                    formatter : function () {

                        var x = '', charSep = cObj.chart.tooltipsepchar;

                        if (this.point.options.tooltext) {

                            x = this.point.options.tooltext;

                        } else {

                            if (this.series.options.FCtype >= 2 && this.series.name !== ' ') {

                                x += this.series.name + charSep;

                            }

                            x += this.x ? this.x + charSep: '';

                            if (this.series.options.FCtype == 1.5 && this.series.type == 'line') {

                                x = this.x + charSep + this.y + '%';

                            }

                            else if (this.series.type == 'pie') {

                                x = (this.point.FCname ? this.point.FCname + charSep: '') + (Math.round(this.percentage * 100) / 100) + (cObj.chart.showpercentintooltip === '0' ? '' : '%');

                            }

                            else if (this.series.options.FCtype === 2.5) {

                                x = formatNumber(this.y, cObj.chart, 1);

                            }

                            else {

                                x += formatNumber(this.y, cObj.chart, 1);

                            }

                            if (this.point.z) {

                                x += charSep + this.point.z;

                            }

                        }

                        return parseStr(x);

                    }

                },

                xAxis: {

                    labels: {

                        rotation: -25,

                        style: {},

                        formatter : function () {

                            return parseStr(typeof this.value === 'string' ? this.value : '');

                        },

                        align: 'right'

                    },

                    categories: [],

                    plotLines: [],

                    plotBands: [],

                    title : {

                        style: {},

                        text: ''

                    }

                },

                yAxis: [{

                    startOnTick: false,

                    endOnTick : false,

                    title : {

                        style: {},

                        text : ''

                    },

                    labels: {

                        style: {},

                        formatter : function () {

                            return parseStr(formatNumber(this.value, cObj.chart, 1));

                        }

                    },

                    plotBands: [],

                    plotLines: []

                }, {

                    gridLineWidth: 0,

                    startOnTick: false,

                    endOnTick : false,

                    title : {

                        style: {},

                        text : ''

                    },

                    labels: {

                        style: {},

                        enabled : false,

                        formatter : function () {

                            return parseStr(formatNumber(this.value, cObj.chart, 2));

                        }

                    },

                    opposite: true

                }],

                exporting: {

                    buttons: {

                        exportButton: {},

                        printButton: {

                            enabled: false

                        }

                    }

                }

            };



        };

        

        ///add xAxis Plot Lines

        function addVline(hc, color, alpha, width, value) {

            hc.xAxis.plotLines.push({

                color: convertColor(color || '#444444', alpha || 100),

                width: width ? width : 1,

                value: value

            });

        }





        ///function to add points in a series

        function addPoint(seriesObj, pointObj, series, chartName, id, HCObj, getScolor, bubbleRatio, FCObj) {

            var x, y, isAbs = FCFCC.valueAbs[chartName], value,

            seriesType = seriesObj.type || HCObj.chart.defaultSeriesType,

            dataseperator, tempY, dataYmax, dataYmin, loopMax;



            //fiend the variable name max and min calculation

            if (!seriesObj.yAxis) {

                dataYmax = 'dataY0max';

                dataYmin = 'dataY0min';

            }

            else {

                dataYmax = 'dataY' + seriesObj.yAxis + 'max';

                dataYmin = 'dataY' + seriesObj.yAxis + 'min';

            }



            //set the looping limit depending upon chart type

            if (series < 7 && series >= 2 && series != 2.5) {

                loopMax = HCObj.xAxis.categories.length;

            }

            else {

                loopMax = pointObj.length;

            }



            //itterate through pointObj

            if (pointObj instanceof Array) {

                for (y = 0; y < loopMax; y += 1) {

                    if (typeof pointObj[y] === 'object') {

                        if (!pointObj[y].vline) {

                            if (seriesObj.cursor != 'pointer' && pointObj[y].link) {

                                seriesObj.cursor = 'pointer';

                            }

                            // add the data point

                            tempY = (isAbs ? Math.abs(parseFloat(pointObj[y].value || pointObj[y].y)):parseFloat(pointObj[y].value || pointObj[y].y));

                            //check whether it is an negative value

                            if (tempY < 0) {

                                HCObj.FCconf.negative = true;

                            }

                            //check whether it is the max value

                            if (typeof HCObj.FCconf[dataYmax] === 'undefined' || tempY > HCObj.FCconf[dataYmax]) {

                                HCObj.FCconf[dataYmax] = tempY;

                            }

                            //check whether it the min value

                            if (typeof HCObj.FCconf[dataYmin] === 'undefined' || tempY < HCObj.FCconf[dataYmin]) {

                                HCObj.FCconf[dataYmin] = tempY;

                            }



                            //set the stacking value

                            if (typeof HCObj.FCconf.stackValue[y] === 'undefined') {

                                HCObj.FCconf.stackValue[y] = tempY;

                            }

                            else {

                                HCObj.FCconf.stackValue[y] += tempY;

                            }

                            seriesObj.data.push({

                                y: tempY || 0,

                                x: (isAbs ? Math.abs(parseFloat(pointObj[y].x)):parseFloat(pointObj[y].x)) || undefined,

                                z: (isAbs ? Math.abs(parseFloat(pointObj[y].z)):parseFloat(pointObj[y].z)) || undefined,

                                color: (series < 2 || pointObj[y].color || pointObj[y].alpha) ? convertColor(pointObj[y].color || (series < 2 && getScolor(y)), pointObj[y].alpha, seriesObj.color): undefined,

                                FCname: series < 2 ? pointObj[y].label : undefined,// for single serease add the label as name

                                link: pointObj[y].link,

                                sliced: pointObj[y].issliced == '1',

                                id: id,

                                displayvalue: pointObj[y].displayvalue,

                                showvalue: pointObj[y].showvalue,

                                tooltext: pointObj[y].tooltext,

                                marker: (seriesType === 'areaspline' || seriesType === 'spline' || seriesType === 'area' || seriesType === 'line') ? {

                                    enabled : pointObj[y].drawanchors ? (pointObj[y].drawanchors == '1' ? true : false) : undefined,

                                    radius: pointObj[y].anchorradius ? pointObj[y].anchorradius : undefined,

                                    symbol: convertAncorSide(parseInt(pointObj[y].anchorsides, 10)),

                                    fillColor: pointObj[y].anchorbgcolor ? convertColor(pointObj[y].anchorbgcolor || 'FFFFFF', pointObj[y].anchorbgalpha || 100) : undefined,

                                    lineColor: pointObj[y].anchorbordercolor ? convertColor(pointObj[y].anchorbordercolor || '767575', pointObj[y].anchoralpha || 100) : undefined,

                                    lineWidth: pointObj[y].anchorborderthickness ? pointObj[y].anchorborderthickness : undefined

                                } : (series === 7.5 ? {

                                    radius: pointObj[y].z ? Math.round((pointObj[y].z / bubbleRatio) * 10) / 10: undefined

                                } : null)

                            });





                            //add category for single series chart

                            if (series < 2) {

                                HCObj.xAxis.categories.push(pointObj[y].showlabel === '0' ? '' : (pointObj[y].label || ''));

                            }

                        }

                        else if (series < 2) {

                            ///if it is a vline then add plotlone or band for it

                            addVline(HCObj, pointObj[y].color, pointObj[y].alpha, pointObj[y].thickness, y - 0.5);

                        }

                    } else if (typeof pointObj[y] === 'string' && FCObj.chart.compactdatamode == '1') {

                        dataseperator = FCObj.chart.dataseparator || '|';

                        value = pointObj[y].split(dataseperator);

                        for (x = 0; x < value.length; x += 1) {

                            tempY = isAbs ? Math.abs(parseFloat(value[x])):parseFloat(value[x]);

                            //check whether it is an negative value

                            if (tempY < 0) {

                                HCObj.FCconf.negative = true;

                            }

                            //check whether it is the max value

                            if (typeof HCObj.FCconf[dataYmax] === 'undefined' || tempY > HCObj.FCconf[dataYmax]) {

                                HCObj.FCconf[dataYmax] = tempY;

                            }

                            //check whether it the min value

                            if (typeof HCObj.FCconf[dataYmin] === 'undefined' || tempY < HCObj.FCconf[dataYmin]) {

                                HCObj.FCconf[dataYmin] = tempY;

                            }

                            seriesObj.data.push({

                                y : tempY || 0

                            });

                        }

                    }

                    else {

                        seriesObj.data.push({y: 0});

                    }

                }

            }

        }





///////function to add category



        function addCategory(obj, series, hc) {

            var x, dataseperator, countCat = 0, zoomCat = [];

            if (obj.categories && obj.categories[0].category) {

                for (x = 0; x < obj.categories[0].category.length; x += 1) {

                    if (typeof obj.categories[0].category[x] === 'object') {

                        if (!obj.categories[0].category[x].vline) {

                            if (series == 2.5) {

                                zoomCat.push(obj.categories[0].category[x].label ? obj.categories[0].category[x].label: '');

                            } else {

                                hc.xAxis.categories.push(obj.categories[0].category[x].label ? obj.categories[0].category[x].label: '');

                            }



                            countCat += 1;

                        }

                        else {

                            addVline(hc, obj.categories[0].category[x].color, obj.categories[0].category[x].alpha, obj.categories[0].category[x].thickness, countCat - 0.5);

                        }

                    } else if (typeof obj.categories[0].category[x] === 'string' && obj.chart.compactdatamode == '1') {

                        dataseperator = obj.chart.dataseparator ? obj.chart.dataseparator : '|';

                        if (series == 2.5) {

                            zoomCat = zoomCat.concat(obj.categories[0].category[x].split(dataseperator));

                        } else {

                            hc.xAxis.categories = hc.xAxis.categories.concat(obj.categories[0].category[x].split(dataseperator));

                        }

                    }

                }

            }

           ///fix of bug #510

            if (series === 2.5) {

                hc.xAxis.maxZoom = 2;

                hc.chart.zoomType = 'x';

                hc.chart.showvalue = obj.chart.showvalues === '1' ? '1' : '0';

                hc.xAxis.categories = undefined;

                hc.xAxis.min = 0;

                hc.xAxis.max = zoomCat.length - 1;

                hc.xAxis.endOnTick = false;

                hc.xAxis.labels.formatter = function () {

                    return  parseStr(zoomCat[this.value]);

                };

            }



        }





        //create MSStacked Chart



        function MSStacked(obj, series, chartName, HCObj, width, hight, id, getScolor) {

            var x, y, z, newSeries, count_set = 0, max_cat = 0, a = [],

            plotWidth = width - (HCObj.chart.margin[1] + HCObj.chart.margin[3]),

            plotHight = hight - (HCObj.chart.margin[0] + HCObj.chart.margin[2]),

            noStack, pointWidth, catWidth, tempheight, maxHight = 0, pointValue = 0;



            // get the no of category

            if (obj.categories && obj.categories[0] && obj.categories[0].category) {

                max_cat = obj.categories[0].category.length;

            }



            //if there has parent dataset trhen ierate bthrough it



            if (obj.dataset && obj.dataset instanceof Array) {

                noStack = obj.dataset.length;

                catWidth = plotWidth / max_cat;

                pointWidth = catWidth / (noStack + 2);

                for (x = 0; x < obj.dataset.length; x += 1) {

                    tempheight = [];

                    //if it has child dataset then itterate through it

                    if (obj.dataset[x].dataset && obj.dataset[x].dataset instanceof Array) {

                        for (y = 0; y < obj.dataset[x].dataset.length ; y += 1) {

                            newSeries = {

                                FCtype: series,

                                type: obj.dataset[x].dataset[y].renderas ? FCFCC.combi[obj.dataset[x].dataset[y].renderas.toLowerCase()]: undefined,

                                name: obj.dataset[x].dataset[y].seriesname ? obj.dataset[x].dataset[y].seriesname: ' ',

                                data: [],

                                color: convertColor(obj.dataset[x].color || getScolor(count_set), obj.dataset[x].dataset[y].alpha || 100),

                                yAxis: obj.dataset[x].dataset[y].parentyaxis == 'S' ? 1 : undefined,

                                showvalue: obj.dataset[x].dataset[y].showvalues,

                                mColum: x,

                                mStack: y

                            };



                            if (obj.dataset[x].dataset[y].data instanceof Array) {

                                for (z = 0; z < max_cat; z += 1) {

                                    tempheight[z] = tempheight[z] ? tempheight[z] : 0;

                                    pointValue = (obj.dataset[x].dataset[y].data[z] && obj.dataset[x].dataset[y].data[z].value) ? parseFloat(obj.dataset[x].dataset[y].data[z].value): '';

                                    tempheight[z] += pointValue ? pointValue : 0;

                                    newSeries.data.push({

                                        MWidth: pointWidth,

                                        MX: (z * catWidth) + ((x + 1) * pointWidth),

                                        MY: tempheight[z],

                                        y: pointValue,

                                        link:  obj.dataset[x].dataset[y].data[z].link,

                                        id: id,

                                        color: obj.dataset[x].dataset[y].data[z].color ? convertColor(obj.dataset[x].dataset[y].data[z].color || getScolor(count_set), obj.dataset[x].dataset[y].data[z].alpha || 100) : undefined

                                    });

                                }

                            }



                            a.push(newSeries);

                            //at the end increament the serease counter

                            count_set += 1;

                        }

                    }

                    for (z = 0; z < max_cat; z += 1) {

                        if (maxHight < tempheight[z]) {

                            maxHight = tempheight[z];

                        }

                    }

                }

            }





            HCObj.yAxis[0].max = maxHight + 5;





            return a;

        }

        



         ///Function To add data & categories

        function addData(obj, series, chartName, hc, width, height, id) {

            var a = [], x, y, z, count_set, getScolor, pareto, yCalTemp;

            //this function widecide the default color for a series or data;

            getScolor = function (index) {

                var palett;

                //if palett color is supplyed then use it

                //check whether it is an coma seperated string then split it into array

                //else use default color palett

                palett = (obj.chart.palettecolors) ? ((typeof obj.chart.palettecolors === 'string') ? obj.chart.palettecolors.split(',') : obj.chart.palettecolors) : FCFCC.color;

                ///return color for the index position

                return palett[index % palett.length];



            };



            //switch depending on the chart's type/series

            switch (series) {

            case 1:  //single series

            case 1.5:  //pareto

                ///options that have to change for pareto chart

                if (series == 1.5) {

                    //set the secondary y axis value max as 100

                    hc.yAxis[1].max = 100;

                    //set the label formater for line series

                    hc.yAxis[1].labels.formatter = function () {

                        return parseStr(this.value + '%');

                    };

                    if (obj.data instanceof Array) {

                        obj.data.sort(function (a, b) {

                            return parseFloat(b.value) - parseFloat(a.value);

                        });

                    }

                }





                    ///// special setings for single series /////

                    //disable the legend for chhart

                hc.legend.enabled = false;





                    //////category  &&  data\\\\\\\



                    //iterate through all the data

                if (obj.data) {

                    z = createSeries(series);

                    addPoint(z, obj.data, series, chartName, id, hc, getScolor);

                     

                     ///pie speciffic functions

                    if (convertNames(chartName) == 'pie') {

                        //revarse the series for pie/douggnut to make it clockwise

                        z.data.reverse();

                        //remove the serease color to avoid onclick discolored slice

                        z.color = undefined;

                        //remove the plotboder

                        hc.chart.plotBorderWidth = 0;

                        //set the max margin

                        x = hc.chart.borderWidth + 1;

                        hc.chart.margin = [hc.chart.margin[0], x, x, x];

                    }

                    a.push(z);

                    //for pareto add the line serease

                    if ((chartName == 'Pareto2D' || chartName == 'Pareto3D') && obj.chart.showcumulativeline !== '0') {

                        pareto = paretoConvert(z.data);

                        a.push(pareto);

                    }

                }

                break;

            case 2:

            case 2.2:

            case 2.5:                

            case 3:                

            case 4:

            case 5:

            case 5.5:

            case 6:

            case 6.5:

                switch (series) {

                case 2.2:

                    hc.yAxis[0].reversed = true;

                    //set the PC reverse chart flag

                    hc.yAxis[0].PCreversed = true;

                    break;

                case 3:

                    if (obj.chart.stack100percent == '1') {

                        hc.plotOptions.series.stacking = 'percent';

                        hc.yAxis[0].labels.formatter = function () {

                            return parseStr(this.value + '%');

                        };

                    } else {

                        hc.plotOptions.series.stacking = 'normal';

                    }

                    break;

                case 5.5:

                    hc.plotOptions.column.stacking = obj.chart.stack100percent == '1' ? 'percent' : 'normal';

                }

                  ////////category////////



                addCategory(obj, series, hc);

                   ////////data////////

                if (series !== 6) {

                    if (obj.dataset) {

                        count_set = 0;

                        for (x = 0;x < obj.dataset.length;x += 1) {

                            z = createSeries(series, convertColor(obj.dataset[x].color ||  getScolor(count_set), obj.dataset[x].alpha ||  100),

                            obj.dataset[x].renderas ? FCFCC.combi[obj.dataset[x].renderas.toLowerCase()]: ((obj.dataset[x].parentyaxis == 'S' && (series == 5 || series == 5.5)) ? 'line': undefined),

                            obj.dataset[x].seriesname, obj.dataset[x].parentyaxis == 'S', obj.dataset[x].showvalues,

                            obj.dataset[x].plotbordercolor ? convertColor(obj.dataset[x].plotbordercolor, obj.dataset[x].plotborderalpha || 95) : undefined,

                            parseInt(obj.dataset[x].plotborderthickness || obj.dataset[x].linethickness, 10) || undefined);



                            var seriesType = z.type || hc.chart.defaultSeriesType;

                            z.marker = (seriesType === 'area' || seriesType === 'line' || seriesType === 'spline' || seriesType === 'areaspline') ? {

                                    enabled : obj.dataset[x].drawanchors ? (obj.dataset[x].drawanchors == '1' ? true : false) : undefined,

                                    radius: obj.dataset[x].anchorradius ? obj.dataset[x].anchorradius : undefined,

                                    symbol: convertAncorSide(parseInt(obj.dataset[x].anchorsides, 10)),

                                    fillColor: obj.dataset[x].anchorbgcolor ? convertColor(obj.dataset[x].anchorbgcolor || 'FFFFFF', obj.dataset[x].anchorbgalpha || 100) : undefined,

                                    lineColor: obj.dataset[x].anchorbordercolor ? convertColor(obj.dataset[x].anchorbordercolor || '767575', obj.dataset[x].anchoralpha || 100) : undefined,

                                    lineWidth: obj.dataset[x].anchorborderthickness ? obj.dataset[x].anchorborderthickness : undefined

                                } : null;







                            count_set += 1;

                            if (obj.dataset[x].data) {

                                addPoint(z, obj.dataset[x].data, series, chartName, id, hc, undefined, undefined, obj);

                            }

                            a.push(z);

                        }

                        if (series == 3 || series == 5.5 || convertNames(chartName) == 'bar') {

                            var tempArr = [];

                            for (x = 0; x < a.length; x += 1) {

                                if (a[x].type) {

                                    tempArr.push(a[x]);

                                } else {

                                    tempArr.splice(0, 0, a[x]);

                                }

                            }

                            a = tempArr;

                            hc.legend.reversed = true;

                        }

                    }

                } else {

                    a = MSStacked(obj, series, chartName, hc, width, height, id, getScolor);

                }

                 



                break;

            case 7:

            case 7.5:

                    ////////special conf. for x-y plot charts

                hc.chart.showvalue = obj.chart.showvalues == '1' ? '1' : '0';



                    ////////category////////



                if (obj.categories && obj.categories[0] && obj.categories[0].category) {

                    for (x = 0;x <  obj.categories[0].category.length; x += 1) {

                        if (obj.categories[0].category[x].showverticalline && obj.categories[0].category[x].showverticalline == '1') {

                            addVline(hc, obj.categories[0].verticallinecolor, obj.categories[0].verticallinealpha, obj.categories[0].verticallinethickness, obj.categories[0].category[x].x);

                        }

                        hc.xAxis.categories[obj.categories[0].category[x].x] = obj.categories[0].category[x].label ? obj.categories[0].category[x].label: '';

                    }

                }



                    ////////data////////



                var bubbleRRatio = maxZVal(obj.dataset) / maxRedious(width, height);

                if (obj.dataset) {

                    count_set = 0;

                    for (x = 0; x < obj.dataset.length; x += 1) {

                        z = createSeries(series, convertColor(obj.dataset[x].color || getScolor(count_set), obj.dataset[x].alpha || 100), obj.dataset[x].renderas ? FCFCC.combi[obj.dataset[x].renderas]: ((obj.dataset[x].parentyaxis == 'S' && (series == 5 || series == 5.5)) ? 'line': undefined), obj.dataset[x].seriesname, obj.dataset[x].parentyaxis == 'S', obj.dataset[x].showvalues, undefined, undefined);

                        z.marker = {

                            symbol: (series == 7.5) ? 'circle' : convertAncorSide(parseInt(obj.dataset[x].anchorsides, 10)),

                            states: {

                                hover: {

                                    enabled: false

                                }

                            }

                        };

                        count_set += 1;

                        if (obj.dataset[x].data) {

                            addPoint(z, obj.dataset[x].data, series, chartName, id, hc, getScolor, bubbleRRatio);

                        }

                        a.push(z);

                    }

                }

                hc.xAxis.max = obj.chart.xaxismaxvalue ? parseInt(obj.chart.xaxismaxvalue, 10): undefined;

                hc.xAxis.min = obj.chart.xaxisminvalue ? parseInt(obj.chart.xaxisminvalue, 10): undefined;

                hc.xAxis.showLastLabel  = true;

                break;

            default:

                break;

            }

            if (!((series === 3 || series === 5.5) && obj.chart.stack100percent === '1') && chartName !== 'Marimekko') {//if it is not an 100percent stack chart

                if (series === 3 || series === 5.5) {

                    hc.FCconf.dataY0max = hc.FCconf.stackValue[0];

                    hc.FCconf.dataY0min = hc.FCconf.stackValue[0];

                    for (y = 1; y < hc.FCconf.stackValue.length; y += 1) {

                        if (hc.FCconf.stackValue[y] > hc.FCconf.dataY0max) {

                            hc.FCconf.dataY0max = hc.FCconf.stackValue[y];

                        }

                        if (hc.FCconf.stackValue[y] < hc.FCconf.dataY0min) {

                            hc.FCconf.dataY0min = hc.FCconf.stackValue[y];

                        }

                    }

                }



                if (series === 1.5 || series === 5.5 || series === 5 || series === 6.5) {

                    yCalTemp = getAxisLimits(hc.FCconf.dataY0max, hc.FCconf.dataY0min, obj.chart.pyaxismaxvalue, obj.chart.pyaxisminvalue, '', obj.chart.setadaptiveymin !== '1');

                    hc.yAxis[0].max = yCalTemp.Max;

                    hc.yAxis[0].min = yCalTemp.Min;

                    if (series !== 1.5) {

                        yCalTemp = getAxisLimits(hc.FCconf.dataY1max, hc.FCconf.dataY1min, obj.chart.syaxismaxvalue, obj.chart.syaxisminvalue, '', obj.chart.setadaptivesymin !== '1');

                        hc.yAxis[1].max = yCalTemp.Max;

                        hc.yAxis[1].min = yCalTemp.Min;

                    }

                }

                else {

                    yCalTemp = getAxisLimits(hc.FCconf.dataY0max, hc.FCconf.dataY0min, obj.chart.yaxismaxvalue, obj.chart.yaxisminvalue, '', obj.chart.setadaptiveymin !== '1');

                    hc.yAxis[0].max = yCalTemp.Max;

                    hc.yAxis[0].min = yCalTemp.Min;

                }

            }

            hc.series = a;

        }



    ///modify as per legend

        function ModyfyLegend(hc, obj) {

            var noSeries = hc.series.length, legendPos, legendWidth, legendHeight;



            if (obj.chart.showlegend == '0') {

                hc.legend.enabled = false;

            } else {

                hc.legend.labelFormatter  = function () {

                    return parseStr(this.name);

                };

                if (obj.chart.interactivelegend == '0') {

                    hc.plotOptions.series.events.legendItemClick = function (event) {

                        return false;

                    };

                    hc.legend.itemStyle.cursor = 'default';

                }

                hc.legend.shadow = obj.chart.legendshadow == '0' ? false : true;

                hc.legend.backgroundColor = convertColor(obj.chart.legendbgcolor || '#ffffff', obj.chart.legendbgalpha || 100);

                hc.legend.borderColor = convertColor(obj.chart.legendbordercolor || '#545454', obj.chart.legendborderalpha || 100);

                hc.legend.borderWidth = obj.chart.legendborderthickness || 1;

                if (obj.reverselegend == '1') {

                    hc.legend.reversed = !hc.legend.reversed;

                }



                if (obj.chart.legendposition == 'RIGHT') {

                    hc.legend.verticalAlign = 'middle';

                    hc.legend.align = 'right';

                    hc.legend.width = 70;

                    hc.legend.x = -15;

                    hc.chart.margin[1] += 85;

                } else {

                    hc.legend.x = 0;

                    hc.chart.margin[2] += 46;

                }

            }



        }



        ////function to enter a text in chart

        function createText(text, top, left) {

            return {

                html: text,

                style: {

                    left: left + 'px',

                    top: top + 'px'

                }

            };



        }





 //function to convert a marimekko chart

        function convertMarimeko(HCObj, FCObj, chartWidth, chartHight, FCCategories) {

            var plotWidth = chartWidth - (HCObj.chart.margin[1] + HCObj.chart.margin[3]),

            plotHight = chartHight - (HCObj.chart.margin[0] + HCObj.chart.margin[2]),

            y, z, arr = [], total = 0, temp, setPersent = false,

            catCountFlag = true, temp2, totalpercent = 0;



            if (HCObj.xAxis.labels.enabled === false && FCObj.chart.showxaxispercentvalues != '0') {

                HCObj.xAxis.title.margin += 15;

                HCObj.chart.margin[2] += 15;



            }

            //set the plotHight quit bigger to addajust xaxispercentvalues

            if (HCObj.xAxis.labels.enabled !== false && FCObj.chart.showxaxispercentvalues != '0') {

                plotHight += 15;

            }

            if (FCCategories && FCCategories[0] && FCCategories[0].category instanceof Array) {