/*
Do not copy or host this file yourself! This is dynamically generated and is
intended to be centralized and common across all Aggregate Knowledge customers.
You should not need to change it.
*/

try
{

    







function replaceAllInstances(string, REToBeReplaced, stringToReplaceWith)
{
    return string.split(REToBeReplaced).join(stringToReplaceWith);
}


function escapeAPIString(string)
{
    return replaceAllInstances(string, /[,]/, 'AKCOMMA');
}

function unescapeAPIString(string)
{
    return replaceAllInstances(string, /AKCOMMA/, ',');
}


function arrayToEscapedString(array)
{
    var outputString = '';
    for(var i = 0; i <= (array.length - 1); i++) 
    {
        if(i != 0) outputString += ',';
        if(array[i].constructor == String)
        {
            outputString += escapeAPIString(array[i]); 
        } else {
            outputString += array[i];
        }
    }
    return outputString;
}


function escapedStringToArray(string, conversionFunction)
{
    var outputArray = string.split(',');
    for(var i = 0; i <= (outputArray.length - 1); i++) 
    {
        outputString += conversionFunction(array[i]);
    }
    return outputArray;
}


function APIParameter(names, defaultValue, isUsedForSilentMode, displayModeName, silentModeName)
{
    this.names = names;
    this.dataType = 'STRING'; 
    this.value = defaultValue;
    this.isUsedForSilentMode = isUsedForSilentMode;
    this.displayModeName = displayModeName;
    this.silentModeName = silentModeName;
    this.populatingExpression = '';
    this.isSentToServer = true;
    this.specificity = 'REQUEST';
}

APIParameter.prototype.names = [];
APIParameter.prototype.dataType = 'STRING';
APIParameter.prototype.value = '';
APIParameter.prototype.isUsedForSilentMode = false;
APIParameter.prototype.displayModeName = '';
APIParameter.prototype.silentModeName = '';
APIParameter.prototype.populatingExpression = '';
APIParameter.prototype.isSentToServer = true;
APIParameter.prototype.specificity = 'ITEM';

APIParameter.prototype.populateValueFromString = function(string)
{
    this.dataType = this.dataType.toUpperCase();
    try
    {
        if(this.dataType == 'STRING') this.value = string;
        if(this.dataType == 'INTEGER') this.value = parseInt(string);
        if(this.dataType == 'FLOAT') this.value = parseFloat(string);
        if(this.dataType == 'BOOLEAN') this.value = (string == 'true');
        if(this.dataType == 'STRING_OR_ARRAY'
            || this.dataType == 'INTEGER_OR_ARRAY'
            || this.dataType == 'FLOAT_OR_ARRAY'
            || this.dataType == 'BOOLEAN_OR_ARRAY')
        {
            if(this.dataType == 'STRING_OR_ARRAY') conversionFunction = unescapeAPIString;
            if(this.dataType == 'INTEGER_OR_ARRAY') conversionFunction = parseInt;
            if(this.dataType == 'FLOAT_OR_ARRAY') conversionFunction = parseFloat;
            if(this.dataType == 'BOOLEAN_OR_ARRAY') conversionFunction = Boolean;
            if(string.indexOf(',') == -1)
            {
                this.value = conversionFunction(string);
            } else {
                this.value = escapedStringToArray(string, conversionFunction);
            }
        }
    } catch(e) {
        this.value = string;
    }
}

APIParameter.prototype.getValueAsString = function()
{
    this.dataType = this.dataType.toUpperCase();
    var output = '';
    if(this.dataType == 'STRING' || this.dataType == 'INTEGER' || this.dataType == 'FLOAT' || this.dataType == 'BOOLEAN')
        output = '' + this.value;
    if(this.dataType == 'STRING_OR_ARRAY')
    {
        if(this.value.constructor == String)
        {
            output = escapeAPIString(this.value);
        } else if(this.value.constructor == Array) {
            output = arrayToEscapedString(this.value);
        }
    }
    if(this.dataType == 'INTEGER_OR_ARRAY'
        || this.dataType == 'FLOAT_OR_ARRAY'
        || this.dataType == 'BOOLEAN_OR_ARRAY')
    {
        if(this.value.constructor == Array)
        {
            output = arrayToEscapedString(this.value);
        } else {
            output = String(this.value);
        }
    }
    return output;
}


APIParameter.prototype.outputToDebug = function(linePrefix)
{
    var output = '';
    if(linePrefix == null) linePrefix = '';
    output += linePrefix + 'Name(s): ' + this.names + '\n';
    output += linePrefix + 'Data type: ' + this.dataType + '\n';
    output += linePrefix + 'Value: ' + this.getValueAsString() + '\n';
    output += linePrefix + 'Display mode name: ' + this.displayModeName + '\n';
    output += linePrefix + 'Silent mode name: ' + this.silentModeName + '\n';
    output += linePrefix + 'Used for silent mode? ' + this.isUsedForSilentMode + '\n';
    output += linePrefix + 'Populating expression: ' + this.populatingExpression + '\n';
    output += linePrefix + 'Sent to server? ' + this.isSentToServer + '\n';
    output += linePrefix + 'Specific to: ' + this.specificity + '\n';
    return output;
}


function APIParameters()
{
    this.paramMap = new Object();
    
        this.paramMap['_akAdditionalDiscountPercent'] = new APIParameter(['_akAdditionalDiscountPercent'], 0, false, 'additionaldiscountpercent', '');
        
            this.paramMap['_akAdditionalDiscountPercent'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['_akListPrice'] = new APIParameter(['_akListPrice'], '', true, '', '');
        
        
        
        
            this.paramMap['_akListPrice'].specificity = 'ITEM';
        
    
        this.paramMap['_akOurPrice'] = new APIParameter(['_akOurPrice'], '', true, '', '');
        
        
        
        
            this.paramMap['_akOurPrice'].specificity = 'ITEM';
        
    
        this.paramMap['akAnchorId'] = new APIParameter(['akAnchorId'], 'akAPI', true, 'anchorid', 'anchorid');
        
        
        
        
    
        this.paramMap['akApiKey'] = new APIParameter(['akApiKey'], '', true, 'apikey', 'apikey');
        
        
        
        
    
        this.paramMap['akDebug'] = new APIParameter(['akDebug'], false, true, '', '');
        
            this.paramMap['akDebug'].dataType = 'BOOLEAN';
        
        
            this.paramMap['akDebug'].isSentToServer = false;
        
        
        
    
        this.paramMap['akExclude'] = new APIParameter(['akExclude'], false, true, '', '');
        
            this.paramMap['akExclude'].dataType = 'BOOLEAN';
        
        
        
        
            this.paramMap['akExclude'].specificity = 'ITEM';
        
    
        this.paramMap['akForceSettingsGroup'] = new APIParameter(['akForceSettingsGroup'], '', false, 'akForceSettingsGroup', '');
        
            this.paramMap['akForceSettingsGroup'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akIntent'] = new APIParameter(['akIntent'], 'VIEW', true, 'intent', 'intent');
        
        
        
        
            this.paramMap['akIntent'].specificity = 'ITEM';
        
    
        this.paramMap['akInternalParameters'] = new APIParameter(['akInternalParameters'], '', true, 'akInternalParameters', 'akInternalParameters');
        
        
        
        
    
        this.paramMap['akItemQuantity'] = new APIParameter(['akItemQuantity'], 1, true, 'itemquantity', 'itemquantity');
        
            this.paramMap['akItemQuantity'].dataType = 'INTEGER_OR_ARRAY';
        
        
        
        
            this.paramMap['akItemQuantity'].specificity = 'ITEM';
        
    
        this.paramMap['akItemsTruncated'] = new APIParameter(['akItemsTruncated'], 0, true, 'itemstruncated', 'itemstruncated');
        
            this.paramMap['akItemsTruncated'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akKeywords'] = new APIParameter(['akKeywords'], '', true, 'keywords', 'tokeywords');
        
        
        
            this.paramMap['akKeywords'].populatingExpression = 'getKeywords()';
        
        
    
        this.paramMap['akLinkShareUrl'] = new APIParameter(['akLinkShareUrl'], '', false, 'linkshareurl', '');
        
        
        
        
    
        this.paramMap['akMaxNum'] = new APIParameter(['akMaxNum'], 5, false, 'maxnum', '');
        
            this.paramMap['akMaxNum'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akMaxThumbnailHeight'] = new APIParameter(['akMaxThumbnailHeight'], -1, false, 'maxthumbnailheight', '');
        
            this.paramMap['akMaxThumbnailHeight'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akMaxThumbnailWidth'] = new APIParameter(['akMaxThumbnailWidth'], -1, false, 'maxthumbnailwidth', '');
        
            this.paramMap['akMaxThumbnailWidth'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akMode'] = new APIParameter(['akMode'], 'DISPLAY', true, 'mode', 'mode');
        
        
        
        
    
        this.paramMap['akNumCols'] = new APIParameter(['akNumCols'], 0, false, 'numcols', '');
        
            this.paramMap['akNumCols'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akNumRows'] = new APIParameter(['akNumRows'], 0, false, 'numrows', '');
        
            this.paramMap['akNumRows'].dataType = 'INTEGER';
        
        
        
        
    
        this.paramMap['akOrientation'] = new APIParameter(['akOrientation'], 'VERTICAL', false, 'orientation', '');
        
        
        
        
    
        this.paramMap['akRestrictIntent'] = new APIParameter(['akRestrictIntent'], '', false, 'restrictintent', '');
        
        
        
        
    
        this.paramMap['akResultsFrameHeight'] = new APIParameter(['akResultsFrameHeight'], 300, false, '', '');
        
            this.paramMap['akResultsFrameHeight'].dataType = 'INTEGER';
        
        
            this.paramMap['akResultsFrameHeight'].isSentToServer = false;
        
        
        
    
        this.paramMap['akResultsFrameWidth'] = new APIParameter(['akResultsFrameWidth'], 275, false, '', '');
        
            this.paramMap['akResultsFrameWidth'].dataType = 'INTEGER';
        
        
            this.paramMap['akResultsFrameWidth'].isSentToServer = false;
        
        
        
    
        this.paramMap['akResultsTitle'] = new APIParameter(['akResultsTitle'], 'People who looked at this also looked at:', false, 'resultstitle', '');
        
        
        
        
    
        this.paramMap['akSourceUrl'] = new APIParameter(['akSourceUrl'], '', true, 'sourceurl', 'sourceurl');
        
        
        
            this.paramMap['akSourceUrl'].populatingExpression = 'window.top.location.toString()';
        
        
    
        this.paramMap['akStylesheetUrl'] = new APIParameter(['akStylesheetUrl'], '', false, 'stylesheeturl', '');
        
        
        
        
    
        this.paramMap['akTarget'] = new APIParameter(['akTarget'], getDefaultTarget(), true, 'target', 'to');
        
            this.paramMap['akTarget'].dataType = 'STRING_OR_ARRAY';
        
        
        
        
            this.paramMap['akTarget'].specificity = 'ITEM';
        
    
        this.paramMap['akTargetDesc'] = new APIParameter(['akDescription', 'akDesc', 'akTargetDesc'], window.top.document.title, true, 'description', 'todesc');
        
            this.paramMap['akTargetDesc'].dataType = 'STRING_OR_ARRAY';
        
        
        
        
            this.paramMap['akTargetDesc'].specificity = 'ITEM';
        
    
        this.paramMap['akTargetType'] = new APIParameter(['akTargetType'], '', true, 'fromtype', 'totype');
        
            this.paramMap['akTargetType'].dataType = 'STRING_OR_ARRAY';
        
        
        
        
            this.paramMap['akTargetType'].specificity = 'ITEM';
        
    
        this.paramMap['akThumbnailHeight'] = new APIParameter(['akThumbnailHeight'], '', true, '', '');
        
            this.paramMap['akThumbnailHeight'].dataType = 'INTEGER';
        
        
        
        
            this.paramMap['akThumbnailHeight'].specificity = 'ITEM';
        
    
        this.paramMap['akThumbnailUrl'] = new APIParameter(['akThumbnailUrl'], '', true, '', '');
        
        
        
        
            this.paramMap['akThumbnailUrl'].specificity = 'ITEM';
        
    
        this.paramMap['akThumbnailWidth'] = new APIParameter(['akThumbnailWidth'], '', true, '', '');
        
            this.paramMap['akThumbnailWidth'].dataType = 'INTEGER';
        
        
        
        
            this.paramMap['akThumbnailWidth'].specificity = 'ITEM';
        
    
        this.paramMap['akUUId'] = new APIParameter(['akUUId'], '', true, 'uuid', 'uuid');
        
        
        
        
    
        this.paramMap['akWebsiteRegion'] = new APIParameter(['akWebsiteRegion'], 'default', false, 'websiteregion', '');
        
        
        
        
    
}

APIParameters.prototype.iterator = function()
{
    return new APIParametersIterator(this);
}


APIParameters.prototype.getParameterByName = function(name)
{
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        for(var i = 0; i <= (param.names.length - 1); i++) 
        {
            if(param.names[i] == name) return param;
        }
    }
    return undefined;
}


APIParameters.prototype.populate = function()
{
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        
        var queryParamFound = false;
        for(var i = 0; i < param.names.length; i++)
        {
            var name = param.names[i];
            var queryParamValue = getParamValueFromQueryString(name);
            if(queryParamValue != null)
            {
                param.populateValueFromString(queryParamValue);
                queryParamFound = true;
                break;
            }
        }
        if(queryParamFound) continue;
        
        if(param.populatingExpression != '')
        {
            param.value = eval(param.populatingExpression);
            continue;
        }
        
        var jsParamFound = false;
        for(var i = 0; i < param.names.length; i++)
        {
            var name = param.names[i];
            if(variableIsDefined(name))
            {
                param.value = eval('window.' + name);
                jsParamFound = true;
                break;
            }
        }
        if(jsParamFound) continue;
        
        for(var i = 0; i < param.names.length; i++)
        {
            var name = param.names[i];
            var paramFormField = null;
            var paramFormFieldArray = document.getElementsByName(name);
            if(paramFormFieldArray != null && paramFormFieldArray.length > 0)
                paramFormField = paramFormFieldArray[paramFormFieldArray.length - 1];
            if(paramFormField == null) var paramFormField = document.getElementById(name);
            if(paramFormField != null && paramFormField.value !== undefined)
            {
                param.populateValueFromString(paramFormField.value);
                break;
            }
        }
    }
}

APIParameters.prototype.isSilentMode = function()
{
    return (this.getParameterByName('akMode').value == 'SILENT');
}

APIParameters.prototype.toString = function()
{
    var output = 'API PARAMETER CONTENTS\n'
        + '======================\n\n';
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        output += param.outputToDebug('    ') + '\n';
    }
    output += '\n======================';
    return output;
}

APIParameters.prototype.toQueryString = function()
{
    var outputString = '';
    var paramCount = 0;
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        var serverSideName = (this.isSilentMode() ? param.silentModeName : param.displayModeName);
        if((!this.isSilentMode() || param.isUsedForSilentMode)
            && param.isSentToServer && serverSideName.length > 0)
        {
            if (paramCount == 0)
            {
                outputString = outputString + '?';
            } else {
                outputString = outputString + '&';
            }
            outputString = outputString + serverSideName + '=' + base64Encode(param.getValueAsString());
            paramCount = paramCount + 1;
        }
    }
    return outputString;
}


function APIParametersIterator(APIParameters)
{
    
    while(this.paramArray.length > 0) this.paramArray.pop();
    for(paramName in APIParameters.paramMap)
    {
        this.paramArray.push(APIParameters.paramMap[paramName]);
    }
}

APIParametersIterator.prototype.paramArray = new Array;
APIParametersIterator.prototype.currentIndex = 0;

APIParametersIterator.prototype.hasNext = function()
{
    return this.currentIndex <= (this.paramArray.length - 1); 
}

APIParametersIterator.prototype.next = function()
{
    var output = this.paramArray[this.currentIndex];
    this.currentIndex++;
    return output;
}

function buildApiParameters()
{
    var params = new APIParameters();
    params.populate();
    return params;
}


    


function escapeCharsAbove255(inputString)
{
    var outputBuffer = '';
    for(var i = 0; i <= (inputString.length - 1); i++) 
    {
        var charCode = inputString.charCodeAt(i);
        if(charCode > 255)
        {
            outputBuffer += '&#' + charCode + ';';
        } else {
            outputBuffer += inputString.charAt(i);
        }
    }
    return outputBuffer;
}


function base64Encode(inputString)
{
    inputString = escapeCharsAbove255(inputString);
    var base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
	var outputArray = new Array;
	var j=0;
	for(var i = 0; i <= (inputString.length - 1); i += 3) 
	{
		var byte1 = inputString.charCodeAt(i);
		var byte2 = inputString.charCodeAt(i + 1);
		var byte3 = inputString.charCodeAt(i + 2);
		var encodedCharIndex1 = byte1 >> 2;
		var encodedCharIndex2 = ((byte1 & 3) << 4) | (byte2 >> 4);
		var encodedCharIndex3 = ((byte2 & 15) << 2) | (byte3 >> 6);
		var encodedCharIndex4 = byte3 & 63;
		if(isNaN(byte2))
		{
			encodedCharIndex3 = encodedCharIndex4 = 64;
		} else if (isNaN(byte3)) {
			encodedCharIndex4 = 64;
		}
		outputArray.push(base64Chars.charAt(encodedCharIndex1));
        outputArray.push(base64Chars.charAt(encodedCharIndex2));
        outputArray.push(base64Chars.charAt(encodedCharIndex3));
        outputArray.push(base64Chars.charAt(encodedCharIndex4));
	}
	return outputArray.join('');
}



    function stripSpaces(string)
{
    if(string.length == 0) return string;
    while(string.charAt(0) == ' ') string = string.substring(1, string.length);
    while(string.charAt(string.length - 1) == ' ') string = string.substring(0, string.length - 1);
    return string;
}


function getCookieValue(name)
{
    var cookieArray = document.cookie.split(';');
    for(var i = 0; i <= (cookieArray.length - 1); i++) 
    {
        var cookieItem = stripSpaces(cookieArray[i]);
        if(cookieItem.indexOf(name) == 0)
            return cookieItem.substring(name.length + 1, cookieItem.length);
    }
    return null;
}


function setCookie(name, value, numDays)
{
    var expireDate = new Date();
    expireDate.setTime(expireDate.getTime() + (numDays * 24 * 60 * 60 * 1000));
    var cookieString = stripSpaces(name)
        + '=' + stripSpaces(value);
        + '; expires=' + expireDate.toGMTString()
        + '; path=/';
    document.cookie = cookieString;
}


function setSessionCookie(name, value)
{
    var cookieString = stripSpaces(name)
        + '=' + stripSpaces(value);
        + '; path=/';
    document.cookie = cookieString;
}

function removeCookie(name)
{
    setCookie(name, '', -1, false);
}


    function generateRandomNumericString(length)
{
    var output = '';
    for(var i = 0; i <= (length - 1); i++) 
    {
        output += (Math.random() * 10).toString().charAt(0);
    }
    return output;
}


    

APIParameter.prototype.clone = function()
{
    var newParam = new APIParameter(this.names, this.value, this.isUsedForSilentMode, this.displayModeName, this.silentModeName);
    newParam.dataType = this.dataType;
    newParam.populatingExpression = this.populatingExpression;
    newParam.isSentToServer = this.isSentToServer;
    newParam.specificity = this.specificity;
    return newParam;
}


APIParameter.prototype.getLength = function()
{
    if(this.value.constructor == Array) return this.value.length;
    return 1;
}


APIParameter.prototype.padToLength = function(length)
{
    if(this.value.constructor == Array)
    {
        for(var i = this.value.length; i <= (length - 1); i++) 
        {
            if(this.dataType == 'STRING_OR_ARRAY') this.value.push('');
            if(this.dataType == 'INTEGER_OR_ARRAY' || this.dataType == 'FLOAT_OR_ARRAY') this.value.push(0);
            if(this.dataType == 'BOOLEAN_OR_ARRAY') this.value.push(false);
        }
    }
}


APIParameter.prototype.canSplit = function()
{
    return (this.value.constructor == Array && this.value.length > 1);
}


APIParameter.prototype.split = function()
{
    if(!this.canSplit()) return [this.clone()];
    var newParam1 = this.clone();
    var newParam2 = this.clone();
    var splitIndex = Math.floor(this.value.length /  2);
    newParam1.value = this.value.slice(0, splitIndex);
    newParam2.value = this.value.slice(splitIndex);
    return [newParam1, newParam2];
}

APIParameters.prototype.clone = function()
{
    var newParams = new APIParameters();
    newParams.paramMap = new Object(); 
    
    for(paramName in this.paramMap)
    {
        newParams.paramMap[paramName] = this.paramMap[paramName].clone();
    }
    return newParams;
}

APIParameters.prototype.getMaxItemSpecificArrayLength = function()
{
    var maxArrayLength = 0;
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        var currentLength = param.getLength();
        if(currentLength > maxArrayLength && param.specificity == 'ITEM') maxArrayLength = currentLength;
    }
    return maxArrayLength;
}


APIParameters.prototype.normalizeItemSpecificArrayLengths = function()
{
    var maxArrayLength = this.getMaxItemSpecificArrayLength();
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        if(param.specificity == 'ITEM') param.padToLength(maxArrayLength);
    }
}


APIParameters.prototype.canSplit = function()
{
    for(var iter = this.iterator(); iter.hasNext(); )
    {
        var param = iter.next();
        if(param.specificity == 'ITEM' && param.canSplit()) return true;
    }
    return false;
}


APIParameters.prototype.split = function()
{
    if(!this.canSplit()) return [this.clone()];
    var newParams1 = this.clone();
    var newParams2 = this.clone();
    for(paramName in newParams1.paramMap)
    {
        var param = newParams1.paramMap[paramName]
        if(param.specificity == 'ITEM' && param.canSplit())
        {
            var splitParamArray = param.split();
            newParams1.paramMap[paramName] = splitParamArray[0];
            newParams2.paramMap[paramName] = splitParamArray[1];
        }
    }
    return [newParams1, newParams2];
}


APIParameters.prototype.convertToSilentMode = function()
{
    this.getParameterByName('akMode').value = 'SILENT';
    
}


function splitApiParametersForUrlLengthLimit(apiParams)
{
    var outputArray = new Array;
    
    var queryStringLengthLimit = 2000;
    
    if(apiParams.toQueryString().length <= queryStringLengthLimit) return [apiParams];
    apiParams.normalizeItemSpecificArrayLengths();
    var inputArray = [apiParams]; 
    
    var discardedObjects = new Array;
    
    for(var i = 0; i < 10000; i++) 
    {
        if(inputArray.length == 0) break;
        var currentParams = inputArray.pop();
        if(currentParams.toQueryString().length <= queryStringLengthLimit) 
        {
            outputArray.push(currentParams);
            continue;
        }
        if(!currentParams.canSplit())
        {
            discardedObjects.push(currentParams);
            continue; 
        }
        var splitArray = currentParams.split();
        if(splitArray.length == 1) continue; 
        for(var j = 0; j <= (splitArray.length - 1); j++)
        {
            if(splitArray[j].toQueryString().length <= queryStringLengthLimit)
            {
                outputArray.push(splitArray[j]); 
            } else {
                inputArray.push(splitArray[j]); 
            }
        }
    }
    
    if(outputArray.length > 1)
    {
        for(var i = 1; i <= (outputArray.length - 1); i++) 
        {
            outputArray[i].convertToSilentMode();
        }
    }
    
    if(outputArray.length > 0)
    {
        var totalTruncatedItems = 0;
        for(var i = 0; i <= (discardedObjects.length - 1); i++)
            totalTruncatedItems += discardedObjects[i].getMaxItemSpecificArrayLength();
        for(var i = 1; i <= (outputArray.length - 1); i++)
            totalTruncatedItems += outputArray[i].getMaxItemSpecificArrayLength();
        outputArray[0].getParameterByName('akItemsTruncated').value = totalTruncatedItems;
    }
    return outputArray;
}


function truncateApiParametersForUrlLengthLimit(apiParams)
{
    var paramsArray = splitApiParametersForUrlLengthLimit(apiParams);
    
    if(paramsArray.length > 0) return paramsArray[0];
}

    
    function getQueryVariable(name)
    {
        var queryTokens = window.location.search.substring(1).split("&");
        for(var i = 0; i <= (queryTokens.length - 1); i++) 
        {
            var nameAndValue = queryTokens[i].split("=");
            if(nameAndValue[0].toLowerCase() == name.toLowerCase())
            {
                if(nameAndValue.length == 1) return '';
                return nameAndValue[1];
            }
        }
        return null;
    }

    
    function spliceArrays(array1, array2)
    {
        var delimiter = '[DELIMITER]';
        var array1AsString = array1.join(delimiter);
        var array2AsString = array2.join(delimiter);
        var unifiedString = array1AsString + delimiter + array2AsString;
        return unifiedString.split(delimiter);
    }

    
    function isProbablyAFormField(obj)
    {
        if(typeof(obj) != 'object') return false;
        
        var probablyAFormFieldRating = 0;
        
        if(obj.form !== undefined) probablyAFormFieldRating++;
        if(obj.tabIndex !== undefined) probablyAFormFieldRating++;
        if(obj.focus !== undefined) probablyAFormFieldRating++;
        if(obj.value !== undefined) probablyAFormFieldRating++;
        if(obj.type !== undefined) probablyAFormFieldRating++;
        
        return (probablyAFormFieldRating >= 3);
        
    }

    function variableIsDefined(varName)
    {
        var varReference = eval('window.' + varName);
        if(varReference == undefined) return false;
        if(isProbablyAFormField(varReference)) return false;
        
        if(varReference.length !== undefined
            && varReference[0] !== undefined
            && isProbablyAFormField(varReference[0]))
            return false;
        return true;
    }

    
    function getParamValueFromQueryString(paramName)
    {
        paramName = paramName.toLowerCase();
        var queryValue = getQueryVariable(paramName);
        var cookieValue = getCookieValue(paramName);
        if(queryValue != null)
        {
            if(cookieValue == null) setSessionCookie(paramName, queryValue);
            return queryValue;
        }
        return cookieValue; 
    }

    function getDefaultTarget()
    {
        var locationObj = window.top.location;
        var url = "";
        
        
        if(locationObj.href) {
            url = locationObj.href.toString()
        } else {
            url = locationObj.toString();
        }
        
        if(url.length >= 4 && url.substring(0, 4) != 'http') return '';
        return url;
    }

    
    function getKeywords()
    {
        
        var apiVarsArray = new Array;
        var varPrefixArray = new Array;
        
        var includeFunctionsArray = new Array;
        
            if(variableIsDefined('_akListPrice'))
            {
                apiVarsArray.push(_akListPrice);
                
                    varPrefixArray.push('_akListPrice:');
                
                includeFunctionsArray.push(new Function('val', 'return true;'));
            }
        
            if(variableIsDefined('_akOurPrice'))
            {
                apiVarsArray.push(_akOurPrice);
                
                    varPrefixArray.push('_akOurPrice:');
                
                includeFunctionsArray.push(new Function('val', 'return true;'));
            }
        
            if(variableIsDefined('akExclude'))
            {
                apiVarsArray.push(akExclude);
                
                    varPrefixArray.push('xcl:');
                
                includeFunctionsArray.push(new Function('val', 'return val;'));
            }
        
            if(variableIsDefined('akKeywords'))
            {
                apiVarsArray.push(akKeywords);
                
                    varPrefixArray.push(''); 
                
                includeFunctionsArray.push(new Function('val', 'return true;'));
            }
        
            if(variableIsDefined('akThumbnailHeight'))
            {
                apiVarsArray.push(akThumbnailHeight);
                
                    varPrefixArray.push('tnh:');
                
                includeFunctionsArray.push(new Function('val', 'return val > 0;'));
            }
        
            if(variableIsDefined('akThumbnailUrl'))
            {
                apiVarsArray.push(akThumbnailUrl);
                
                    varPrefixArray.push('tn:');
                
                includeFunctionsArray.push(new Function('val', 'return val.length > 0;'));
            }
        
            if(variableIsDefined('akThumbnailWidth'))
            {
                apiVarsArray.push(akThumbnailWidth);
                
                    varPrefixArray.push('tnw:');
                
                includeFunctionsArray.push(new Function('val', 'return val > 0;'));
            }
        
        var currentKeywordStringIndex = 0;
        
        var packedStringArray = new Array;
        
        while(true && currentKeywordStringIndex < 1000) 
        {
            
            var currentPackedString = '';
            
            for(var i = 0; i <= (apiVarsArray.length - 1); i++) 
            {
                var currentVarValue = undefined;
                if(apiVarsArray[i].constructor != Array && currentKeywordStringIndex == 0)
                {
                    currentVarValue = apiVarsArray[i];
                } else if(apiVarsArray[i].constructor == Array && apiVarsArray[i].length > currentKeywordStringIndex) {
                    
                    currentVarValue = apiVarsArray[i][currentKeywordStringIndex];
                }
                if(currentVarValue != undefined && includeFunctionsArray[i](currentVarValue))
                {
                    currentKeyword = varPrefixArray[i] + currentVarValue;
                    if(currentPackedString.length > 0) currentPackedString += ' ';
                    currentPackedString += currentKeyword;
                }
            }
            if(currentPackedString.length > 0)
            {
                packedStringArray.push(currentPackedString);
            } else {
                break;
            }
            currentKeywordStringIndex++;
        }
        return packedStringArray;
    }

    function getBoxUrl(apiParams)
    {
        var iframeUrl = 'http://api.aggregateknowledge.com/2007/01/15/results/'
            + generateRandomNumericString(7)
            + '.js'
            + apiParams.toQueryString();
        return iframeUrl;
    }

    function submitApiData(apiParams)
    {
        
        var boxScript = document.createElement('script');
        var boxUrl = getBoxUrl(apiParams);
        log('Box URL: ' + boxUrl);
        boxScript.setAttribute('src', boxUrl);
        document.getElementsByTagName('head')[0].appendChild(boxScript);
        
    }

    
    function log(logString)
    {
        if(window.debugOutput
            && window.debugOutput.document
            && window.debugOutput.document.getElementById("debugLogger"))
        {
            var timeStampString = 'Log output at ' + (new Date()).toString();
            window.debugOutput.document.getElementById("debugLogger").value += timeStampString + ':\n';
            window.debugOutput.document.getElementById("debugLogger").value += logString + '\n\n';
        }
    }

    function setUpLogger()
    {
        if(variableIsDefined('debugOutput')) return;

        window.debugOutput = open('', '_blank');
        window.debugOutput.document.title = 'API Debug Log';

        var titleText = window.debugOutput.document.createElement('p');
        titleText.innerHTML = 'API debug log:<br><br>';

        var textArea = window.debugOutput.document.createElement('textarea');
        textArea.setAttribute('rows', '35');
        textArea.setAttribute('cols', '120');
        textArea.setAttribute('id', 'debugLogger');

        window.debugOutput.document.body.appendChild(titleText);
        window.debugOutput.document.body.appendChild(textArea);

        window.debugOutput.blur(); 
    }

    
    function addProtectiveStylingToAnchor(apiParams)
    {
        try 
        {
            var akAnchor = document.getElementById(apiParams.getParameterByName('akAnchorId').getValueAsString());
            if(akAnchor == null) return;
            akAnchor.style.textDecoration = 'none';
            akAnchor.style.fontWeight = 'normal';
        } catch(e) {}
    }

    
    function akExecute()
    {
        var params = buildApiParameters();
        params = truncateApiParametersForUrlLengthLimit(params);
        if(params.getParameterByName('akDebug').value) setUpLogger();
        log(params.toString());
        addProtectiveStylingToAnchor(params);
        submitApiData(params);
    }

    akExecute();

} catch(akException) {
    
    try
    {
        var queryString = 'pageurl=' + window.top.location.toString();
        if(akException.message) queryString += '&message=' + akException.message;
        if(akException.name) queryString += '&name=' + akException.name;
        if(akException.description) queryString += '&description=' + akException.description;
        if(akException.number) queryString += '&number=' + akException.number;
        var url = 'http://api.aggregateknowledge.com/jserror/'
            + generateRandomNumericString(7)
            + '.html'
            + '?' + queryString;
        var akErrorIframe = document.createElement('iframe');
        akErrorIframe.setAttribute('border', '0');
        akErrorIframe.setAttribute('frameborder', '0');
        akErrorIframe.setAttribute('width', '0');
        akErrorIframe.setAttribute('height', '0');
        akErrorIframe.setAttribute('scrolling', 'no');
        akErrorIframe.setAttribute('src', url);
        document.body.appendChild(akErrorIframe);
    } catch(e) {  }
}