/*****************************************************************************
******************************************************************************

f_placard.js

Written by Chris Harding and Joshua McKinney
© Copyright F1 Solutions Pty Ltd 2003

This file holds the placard manipulation code for some pages.

Production Version 1.4.2 - 1 April 2005

******************************************************************************
*****************************************************************************/

/******************************************/
/*  locals                                */
/******************************************/
// Grand Total array
// One entry for each good entered
var aGrandTotal = new Array();

// Area Total array
// One entry for each area
var aAreaTotal = new Array();

// Area Aerosol Quantity Total array
// One entry for each area
// same number of fields as Area Total Array
var aAerosolTotal = new Array();

// Area Cryogenic Quantity Total array
// One entry for each area
// same number of fields as Area Total Array
var aCryogenicTotal = new Array();

// Area Placard array
// One entry for each placard reason for each area
var aAreaPlacard = new Array();

// Area Placard Cause array
// One entry for each placard for each area
var aAreaPlacardCause = new Array();

// number of fields in each Area Placard Cause array item
var intAreaPlacardCauseFC = 3;

var aPremiseTotal = new Array(intAreaTotalFC);

// Area Bulk Placard array
// End entry per bulk placard
var aBulkPlacard = new Array();
// number of fields in each BulkPlacard array item
var intBulkPlacardFC = 9;
// K. Flattery, VWA amendments
var quantityGrandTotal = 0;
/*******************************************/
/*  end globals                            */
/*******************************************/


/* Function: placardPremises()                             */
/* This function runs the complete placard routine, loads  */
/* the data into the local arrays and then checks the      */
/* placarding and manifest requirements.                   */
/* INPUTS : none                                           */
/* OUTPUTS: none                                           */
function placardPremises() {
    initialiseArrays();
    loadGoodsLocally('placardPremises');
    loadGoodsIntoPremises();
    checkAllPremises();
}



/* Function: initialiseArrays()                            */
/* This function sets up all the local arrays so they are  */
/* ready to hold data.                                     */
/* INPUTS : none                                           */
/* OUTPUTS: none                                           */
function initialiseArrays() {
    aGrandTotal.length=0;
    for(iATA=0; iATA<numPremises; iATA++)   {
        aAreaTotal[iATA] = new Array(intAreaTotalFC);
        aAreaTotal[iATA][eATAStorageArea] = iATA;
        for(iATAField=1; iATAField<intAreaTotalFC-2; iATAField++) {
            aAreaTotal[iATA][iATAField] = 0;
        }
        aAreaTotal[iATA][eATAHasFireRisk] = false;
        aAreaTotal[iATA][eATAClassCount] = 0;
    }
    for(iAPR=0; iAPR<numPremises; iAPR++) {
        aAreaPlacard[iAPR] = new Array(intAreaPlacardFC);
        aAreaPlacard[iAPR][eAPRStorageArea] = iAPR;
        for(iAPRField=1; iAPRField<intAreaPlacardFC; iAPRField++) {
            aAreaPlacard[iAPR][iAPRField] = false;
        }
    }
    aAreaPlacardCause.length=0;
    for(iAeroTA=0; iAeroTA<numPremises; iAeroTA++) {
        aAerosolTotal[iAeroTA] = new Array(intAreaTotalFC);
        aAerosolTotal[iAeroTA][eATAStorageArea] = iAeroTA;
        for(iAPCField=1; iAPCField<intAreaTotalFC; iAPCField++)
        {
            aAerosolTotal[iAeroTA][iAPCField] = 0;
        }
    }
    for(iCryoTA=0; iCryoTA<numPremises; iCryoTA++) {
        aCryogenicTotal[iCryoTA] = new Array(intAreaTotalFC);
        aCryogenicTotal[iCryoTA][eATAStorageArea] = iCryoTA;
        for(iAPCField=1; iAPCField<intAreaTotalFC; iAPCField++) {
            aCryogenicTotal[iCryoTA][iAPCField] = 0;
        }
    }
    aBulkPlacard.length=0;
    for(i=1; i<intAreaTotalFC-2; i++) {
        aPremiseTotal[i] = 0;
    }
    aPremiseTotal[eATAHasFireRisk] = false;
    aPremiseTotal[eATAClassCount] = 0;
}



/* Function: checkForItem123Placard(pintPremise)           */
/* This function checks to see if a placard is required    */
/* for any item 1, 2 or 3.                                 */
/* Mainly used to determine if a mixed placard or class    */
/* placard should be displayed when there are both.        */
/* INPUTS : int                                            */
/* OUTPUTS: boolean                                           */
function checkForItem123Placard(pintPremise) {
    blnFound = false;
    for(a=0; a<aAreaPlacard.length; a++) {
        if(aAreaPlacard[a][eAPRStorageArea] == pintPremise) {
            for(b=0; b<eAPRMixedClass; b++) {
                if(aAreaPlacard[a][b] == true) {
                    blnFound = true;
                    break;
                }
            }
        }
    }
    return blnFound;
}


function isGoodFireRisk(aGoodsData) {
    return ((parseInt(aGoodsData[eGAQuantity])>0) &&
        (aGoodsData[eGTAClass]==Class_2_1 ||
        aGoodsData[eGTAClass]==Class_2_1_C ||
        aGoodsData[eGTAClass]==Class_2_1_A ||
        aGoodsData[eGTAClass]==Class_3 ||
        aGoodsData[eGTAClass]==Class_4_1 ||
        aGoodsData[eGTAClass]==Class_4_2 ||
        aGoodsData[eGTAClass]==Class_4_3 ||
        aGoodsData[eGTAClass]==Class_5_1 ||
        aGoodsData[eGTAClass]==Class_5_2 ||
        aGoodsData[eGTASubrisk1]==Class_2_1 ||
        aGoodsData[eGTASubrisk1]==Class_3 ||
        aGoodsData[eGTASubrisk1]==Class_4_1 ||
        aGoodsData[eGTASubrisk1]==Class_4_2 ||
        aGoodsData[eGTASubrisk1]==Class_4_3 ||
        aGoodsData[eGTASubrisk1]==Class_5_1 ||
        aGoodsData[eGTASubrisk1]==Class_5_2 ||
        aGoodsData[eGTASubrisk2]==Class_2_1 ||
        aGoodsData[eGTASubrisk2]==Class_3 ||
        aGoodsData[eGTASubrisk2]==Class_4_1 ||
        aGoodsData[eGTASubrisk2]==Class_4_2 ||
        aGoodsData[eGTASubrisk2]==Class_4_3 ||
        aGoodsData[eGTASubrisk2]==Class_5_1 ||
        aGoodsData[eGTASubrisk2]==Class_5_2))
}


/* Function: addToGrandTotalArray(aGoodsData)              */
/* This function adds the good specified by aGoodsData to  */
/* the grand total array for goods, calculating if it is a */
/* firerisk at the same time.                              */
/* INPUTS : array                                          */
/* OUTPUTS: none                                           */
function addToGrandTotalArray(aGoodsData) {
    // fire risk
    var blnIsFireRisk = isGoodFireRisk(aGoodsData);

    var intArrayLength = aGrandTotal.length;

    aGrandTotal[intArrayLength] = new Array(intGrandTotalFC);
    aGrandTotal[intArrayLength][eGTAName] = aGoodsData[eGAName];
    aGrandTotal[intArrayLength][eGTAUN] = aGoodsData[eGAUN];
    aGrandTotal[intArrayLength][eGTAClass] = parseInt(aGoodsData[eGAClass]);
    aGrandTotal[intArrayLength][eGTASubrisk1] = parseInt(aGoodsData[eGASubrisk1]);
    aGrandTotal[intArrayLength][eGTASubrisk2] = parseInt(aGoodsData[eGASubrisk2]);
    aGrandTotal[intArrayLength][eGTAIsFireRisk] = blnIsFireRisk;
    aGrandTotal[intArrayLength][eGTAPackingGroup] = parseInt(aGoodsData[eGAPackingGroup]);
    aGrandTotal[intArrayLength][eGTAStorageArea] = parseInt(aGoodsData[eGAStorageArea]);
    aGrandTotal[intArrayLength][eGTAStorageType] = parseInt(aGoodsData[eGAStorageType]);
    aGrandTotal[intArrayLength][eGTAQuantity] = parseInt(aGoodsData[eGAQuantity]);
    aGrandTotal[intArrayLength][eGTACapacity] = parseInt(aGoodsData[eGACapacity]);
    aGrandTotal[intArrayLength][eGTAContainerID] = aGoodsData[eGAContainerID];
    aGrandTotal[intArrayLength][eGTAHazchem] = aGoodsData[eGAHazchem];
    aGrandTotal[intArrayLength][eGTAShippingName] = aGoodsData[eGAShippingName];
    aGrandTotal[intArrayLength][eGTAC1Isolated] = aGoodsData[eGAC1Isolated];
    aGrandTotal[intArrayLength][eGTAExempt] = aGoodsData[eGAExempt];
    
    if(parseInt(aGoodsData[eGAQuantity])>0) blnMustComply = true; // flag for 'must comply' field
    //alert('aGoodsData['+eGAQuantity+']) = ' + aGoodsData[eGAQuantity] + ', blnMustComply: ' + blnMustComply);
}



/* Function: addToAreaTotalArray(strStorageArea, strAmount, intFieldIndex)*/
/* This function adds the amount specified by strAmount to */
/* the area total array for the area specified by          */
/* strStorageArea and for the class specified by           */
/* intFieldIndex.                                          */
/* To do this we must first check to see if we currently   */
/* have a row for this storage area and create it if we    */
/* dont.                                                   */
/* INPUTS : string, string, int                            */
/* OUTPUTS: none                                           */
function addToAreaTotalArray(strStorageArea, strAmount, intFieldIndex) {
    var blnFound = false;
    var intArrayLength = aAreaTotal.length;
    for(idxx=0; idxx<intArrayLength; idxx++) {
        if(strStorageArea == aAreaTotal[idxx][eATAStorageArea]) {
            blnFound = true;
            if(intFieldIndex==eATAHasFireRisk) {
                aAreaTotal[idxx][intFieldIndex] |= strAmount;
            } else {
                if(aAreaTotal[idxx][intFieldIndex] == 0) {
                    switch(intFieldIndex) {
                        case eATAClass21:
                        case eATAClass23:
                        case eATAClassAero:
                        case eATAClassCryo:
                        case eATAClass3Pack1:
                        case eATAClass3Pack2:
                        case eATAClass3Pack3:
                        case eATAClass41Pack1:
                        case eATAClass41Pack2:
                        case eATAClass41Pack3:
                        case eATAClass42Pack1:
                        case eATAClass42Pack2:
                        case eATAClass42Pack3:
                        case eATAClass43Pack1:
                        case eATAClass43Pack2:
                        case eATAClass43Pack3:
                        case eATAClass51Pack1:
                        case eATAClass51Pack2:
                        case eATAClass51Pack3:
                        case eATAClass52Pack1:
                        case eATAClass52Pack2:
                        case eATAClass52Pack3:
                        case eATAClass61Pack1:
                        case eATAClass61Pack2:
                        case eATAClass61Pack3:
                        case eATAClass8Pack1:
                        case eATAClass8Pack2:
                        case eATAClass8Pack3:
                        case eATAClass9Pack2:
                        case eATAClass9Pack3:
                        case eATAGTDTT:
                        case eATAClass1:
                            aAreaTotal[idxx][eATAClassCount]++; break;
                        // ASSUMPTION: 2.2Sub5.1 and 2.2Other are not considered mixed goods
                        case eATAClass22Sub51:
                        case eATAClass22SubNot51:
                            if(aAreaTotal[idxx][eATAClass22Sub51] == 0 &&
                                    aAreaTotal[idxx][eATAClass22SubNot51] == 0) {
                                aAreaTotal[idxx][eATAClassCount]++;
                            }
                            break;
                        case eATAC1Bulk:
                        case eATAC1Packaged:
                        case eATAC1BulkNotIsolated:
                        case eATAC1PackagedNotIsolated:
                            if(aAreaTotal[idxx][eATAC1Bulk] == 0 &&
                                    aAreaTotal[idxx][eATAC1Packaged] == 0 &&
                                    aAreaTotal[idxx][eATAC1PackagedNotIsolated] == 0 &&
                                    aAreaTotal[idxx][eATAC1BulkNotIsolated] == 0) {
                                aAreaTotal[idxx][eATAClassCount]++;
                            }
                            break;
                        case eATAC2Bulk:
                        case eATAC2Packaged:
                            break;
                    }
                }
            aAreaTotal[idxx][intFieldIndex] += parseInt(strAmount);
            }
            break;
        }
    }
    if(!blnFound) {
        for(idxx=0; idxx<intArrayLength; idxx++) {
            if(aAreaTotal[idxx][eATAStorageArea] == -1) {
                aAreaTotal[idxx][eATAStorageArea] = parseInt(strStorageArea);
                blnFound = true;
                if(intFieldIndex==eATAHasFireRisk) {
                    // use OR-equals operator
                    aAreaTotal[idxx][intFieldIndex] = aAreaTotal[idxx][intFieldIndex] || strAmount;
                }
                else {
                    if(aAreaTotal[idxx][intFieldIndex] == 0) {
                        switch(intFieldIndex) {
                            case eATAClass21:
                            case eATAClass23:
                            case eATAClassAero:
                            case eATAClassCryo:
                            case eATAClass3Pack1:
                            case eATAClass3Pack2:
                            case eATAClass3Pack3:
                            case eATAClass41Pack1:
                            case eATAClass41Pack2:
                            case eATAClass41Pack3:
                            case eATAClass42Pack1:
                            case eATAClass42Pack2:
                            case eATAClass42Pack3:
                            case eATAClass43Pack1:
                            case eATAClass43Pack2:
                            case eATAClass43Pack3:
                            case eATAClass51Pack1:
                            case eATAClass51Pack2:
                            case eATAClass51Pack3:
                            case eATAClass52Pack1:
                            case eATAClass52Pack2:
                            case eATAClass52Pack3:
                            case eATAClass61Pack1:
                            case eATAClass61Pack2:
                            case eATAClass61Pack3:
                            case eATAClass8Pack1:
                            case eATAClass8Pack2:
                            case eATAClass8Pack3:
                            case eATAClass9Pack2:
                            case eATAClass9Pack3:
                            case eATAGTDTT:
                            case eATAClass1:
                                aAreaTotal[idxx][eATAClassCount]++; break;
                            case eATAClass22Sub51:
                            case eATAClass22SubNot51:
                                if(aAreaTotal[idxx][eATAClass22Sub51] == 0 && aAreaTotal[idxx][eATAClass22SubNot51] == 0) aAreaTotal[idxx][eATAClassCount]++;
                                break;
                            case eATAC1Bulk:
                            case eATAC1Packaged:
                            case eATAC1PackagedNotIsolated:
                            case eATAC1BulkNotIsolated:
                                if (aAreaTotal[idxx][eATAC1Bulk] == 0
                                    && aAreaTotal[idxx][eATAC1Packaged] == 0
                                    && aAreaTotal[idxx][eATAC1BulkNotIsolated] == 0
                                    && aAreaTotal[idxx][eATAC1PackagedNotIsolated] == 0) {
                                    aAreaTotal[idxx][eATAClassCount]++;
                                }
                                break;
                            case eATAC2Bulk:
                            case eATAC2Packaged:
                                break;
                        }
                    }
                    // use PLUS-equals operator
                    aAreaTotal[idxx][intFieldIndex] += parseInt(strAmount);
                }
                break;
            }
        }
    }
}


// DETERMINED AS NOT USED (K. Flattery, 030507)
/* Function: addToAerosolTotalArray(strStorageArea, strAmount, intFieldIndex)*/
/* This function adds the amount specified by strAmount to */
/* the aerosol total array for the area specified by       */
/* strStorageArea and for the class specified by           */
/* intFieldIndex.                                          */
/* To do this we must first check to see if we currently   */
/* have a row for this storage area and create it if we    */
/* dont.                                                   */
/* INPUTS : string, string, int                            */
/* OUTPUTS: none                                           */
//function addToAerosolTotalArray(strStorageArea, strAmount, intFieldIndex) {
//    var blnFound = false;
//    var intArrayLength = aAerosolTotal.length;
//    for(idxx=0; idxx<intArrayLength; idxx++) {
//        if(strStorageArea == aAerosolTotal[idxx][eATAStorageArea]) {
//            blnFound = true;
//            // use PLUS-equals operator
//            aAerosolTotal[idxx][intFieldIndex] += parseInt(strAmount);
//            break;
//        }
//    }
//    if(!blnFound) {
//        for(idxx=0; idxx<intArrayLength; idxx++) {
//            if(aAerosolTotal[idxx][eATAStorageArea] == -1) {
//                aAerosolTotal[idxx][eATAStorageArea] = parseInt(strStorageArea);
//                blnFound = true;
//                // use PLUS-equals operator
//                aAerosolTotal[idxx][intFieldIndex] += parseInt(strAmount);
//                break;
//            }
//        }
//    }
//}


// DETERMINED AS NOT USED (K. Flattery, 030507)
/* Function: addToCryogenicTotalArray(strStorageArea, strAmount, intFieldIndex)*/
/* This function adds the amount specified by strAmount to */
/* the cryogenics total array for the area specified by    */
/* strStorageArea and for the class specified by           */
/* intFieldIndex.                                          */
/* To do this we must first check to see if we currently   */
/* have a row for this storage area and create it if we    */
/* dont.                                                   */
/* INPUTS : string, string, int                            */
/* OUTPUTS: none                                           */
//function addToCryogenicTotalArray(strStorageArea, strAmount, intFieldIndex) {
//    var blnFound = false;
//    var intArrayLength = aCryogenicTotal.length;
//    for(idxx=0; idxx<intArrayLength; idxx++) {
//        if(strStorageArea == aCryogenicTotal[idxx][eATAStorageArea]) {
//            blnFound = true;
//            // use PLUS-equals operator
//            aCryogenicTotal[idxx][intFieldIndex] += parseInt(strAmount);
//            break;
//        }
//    }
//    if(!blnFound) {
//        for(idxx=0; idxx<intArrayLength; idxx++) {
//            if(aCryogenicTotal[idxx][eATAStorageArea] == -1) {
//                aCryogenicTotal[idxx][eATAStorageArea] = parseInt(strStorageArea);
//                blnFound = true;
//                // use PLUS-equals operator
//                aCryogenicTotal[idxx][intFieldIndex] += parseInt(strAmount);
//                break;
//            }
//        }
//    }
//}


/* **************************************************************************/
/* Function: addToAreaPlacardArray(strStorageArea, blnTrueFalse,            */
/*      intFieldIndex, strReason, blnIgnoreIfExisting)                      */
/*                                                                          */
/* This function adds a placard reason for the storage                      */
/* area specified by strStorageArea for the class                           */
/* specified by intFieldIndex with the reason specified by                  */
/* strReason.                                                               */
/* blnTrueFalse is a flag that lets you only trigger a                      */
/* placard reason if one is already needed.                                 */
/* blnIgnoreIfExisting is a flag that lets you ignore a                     */
/* placard reason if one is needed already                                  */
/*                                                                          */
/* INPUTS : string, boolean, int, string, boolean                           */
/* OUTPUTS: none                                                            */
/* **************************************************************************/
function addToAreaPlacardArray(strStorageArea, blnTrueFalse, intFieldIndex, strReason, blnIgnoreIfExisting) {
    var blnFound = false;
    var blnPlacardNeededAlready = false;
    var intArrayLength = aAreaPlacard.length;
    for(idxxx=0; idxxx<intArrayLength; idxxx++) {
        if(strStorageArea == aAreaPlacard[idxxx][eAPRStorageArea]) {
            // found existing entry for that area
            blnFound = true;
            // use OR-equals operator
            if(aAreaPlacard[idxxx][intFieldIndex] == true) 
                blnPlacardNeededAlready = true;
            aAreaPlacard[idxxx][intFieldIndex] = aAreaPlacard[idxxx][intFieldIndex] || blnTrueFalse;
            break;
        }
    }
    if(!blnFound) { // add a new entry
        for(idxxx=0; idxxx<intArrayLength; idxxx++) {
            if(aAreaPlacard[idxxx][eAPRStorageArea] == -1) {
                // use OR-equals operator
                aAreaPlacard[idxxx][eAPRStorageArea] = parseInt(strStorageArea);
                aAreaPlacard[idxxx][intFieldIndex] = aAreaPlacard[idxxx][intFieldIndex] || blnTrueFalse;
                break;
            }
        }
    }
    /*if (intFieldIndex == eAPRMixedClass) {
        for(idxxx=0; idxxx<intArrayLength; idxxx++) {
            alert('eAPRMixedClass, aAreaPlacard['+idxxx+']['+intFieldIndex+'] = ' + aAreaPlacard[idxxx][intFieldIndex]);
        }
    }*/
    if(strReason && !(blnPlacardNeededAlready && blnIgnoreIfExisting)) {
        addToAreaPlacardCauseArray(strStorageArea, convertAPRtoClass(intFieldIndex), strReason);
    }
}



/* Function: addToAreaPlacardCauseArray(intStorageArea, strClass, strReason)*/
/* This function adds the reason specified by strReason to */
/* the storage area specified by intStorageArea for the    */
/* class specified by strClass.                            */
/* INPUTS : int, string, string                            */
/* OUTPUTS: none                                           */
function addToAreaPlacardCauseArray(intStorageArea, strClass, strReason) {
    var intArrayLength = aAreaPlacardCause.length;
    var blnFound = false;
    // check to see if that class already has a placard and if so, ignore
    for(idxxx=0; idxxx<intArrayLength; idxxx++) {
        if (intStorageArea == aAreaPlacardCause[idxxx][eAPCStorageArea] &&
                strClass == aAreaPlacardCause[idxxx][eAPCClass]) {
            // found existing entry for that class
            blnFound = true;
            break;
        }
    }
    if(!blnFound) { // add a new entry
        aAreaPlacardCause[intArrayLength] = new Array(intAreaPlacardCauseFC);
        aAreaPlacardCause[intArrayLength][eAPRStorageArea] = intStorageArea;
        aAreaPlacardCause[intArrayLength][eAPCClass] = strClass;
        aAreaPlacardCause[intArrayLength][eAPCReason] = strReason;
        aAreaPlacardCause[intArrayLength][eAPCManifestLevel] = 0; // by default
    }
}


// DETERMINED AS NOT USED (K. Flattery, 030507)
/* Function: addAerosolPlacard(intPremise, strReason)      */
/* This function adds a placard to the storage area        */
/* specified by intPremise with the reason specified by    */
/* strReason.                                              */
/* The class is determined by checking the aerosol total   */
/* array.                                                  */
/* INPUTS : int, string                                    */
/* OUTPUTS: none                                           */
//function addAerosolPlacard(intPremise, strReason) {
//    // check each row of array
//    for(i=0; i<aAerosolTotal.length; i++) {
//        // check for correct storage area
//        if(aAerosolTotal[i][eATAStorageArea] == intPremise) {
//            if(aAerosolTotal[i][eATAClass21] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass21,
//                        strReason + " (Aerosol)");
//            }
//            if (aAerosolTotal[i][eATAClass22Sub51] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51,
//                        strReason + " (Aerosol)");
//            }
//            if (aAerosolTotal[i][eATAClass22SubNot51] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass22,
//                        strReason + " (Aerosol)");
//            }
//            if (aAerosolTotal[i][eATAClass23] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass23,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass3Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass3Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass3Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass3,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass41Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass41Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass41Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass4,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass42Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass42Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass42Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass4,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass43Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass43Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass43Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass4,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass51Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass51Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass51Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass5,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass52Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass52Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass52Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass5,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass61Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass61Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass61Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass6,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass8Pack1] > 0) ||
//                    (aAerosolTotal[i][eATAClass8Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass8Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass8,
//                        strReason + " (Aerosol)");
//            }
//            if ((aAerosolTotal[i][eATAClass9Pack2] > 0) ||
//                    (aAerosolTotal[i][eATAClass9Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass9,
//                        strReason + " (Aerosol)")
//            }
//        }
//    }
//}


// DETERMINED AS NOT USED (K. Flattery, 030507)
/* Function: addCryogenicPlacard(intPremise, strReason)    */
/* This function adds a placard to the storage area        */
/* specified by intPremise with the reason specified by    */
/* strReason.                                              */
/* The class is determined by checking the cryogenic total */
/* array.                                                  */
/* INPUTS : int, string                                    */
/* OUTPUTS: none                                           */
//function addCryogenicPlacard(intPremise, strReason) {
//    // check each row of array
//    for(i=0; i<aAerosolTotal.length; i++) {
//        // check for correct storage area
//        if(aCryogenicTotal[i][eATAStorageArea] == intPremise) {
//            if (aCryogenicTotal[i][eATAClass21] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass21,
//                        strReason+" (Cryogenic)")
//            }
//            if (aCryogenicTotal[i][eATAClass22Sub51] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51,
//                        strReason+" (Cryogenic)")
//            }
//            if (aCryogenicTotal[i][eATAClass22SubNot51] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass22,
//                        strReason+" (Cryogenic)")
//            }
//            if (aCryogenicTotal[i][eATAClass23] > 0) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass23,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass3Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass3Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass3Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass3,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass41Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass41Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass41Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass4,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass42Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass42Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass42Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass4,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass43Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass43Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass43Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass4,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass51Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass51Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass51Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass5,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass52Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass52Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass52Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass5,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass61Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass61Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass61Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass6,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass8Pack1] > 0) ||
//                    (aCryogenicTotal[i][eATAClass8Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass8Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass8,
//                        strReason+" (Cryogenic)")
//            }
//            if ((aCryogenicTotal[i][eATAClass9Pack2] > 0) ||
//                    (aCryogenicTotal[i][eATAClass9Pack3] > 0)) {
//                addToAreaPlacardArray(intPremise, true, eAPRClass9,
//                        strReason+" (Cryogenic)")
//            }
//        }
//    }
//}


/* **************************************************************************/
/* Function: addBulkPlacard(intStorageArea, intClass, intSubrisk1,          */
/*      intSubrisk2, strName, strUN, strHazchem, strExempt)                 */
/*                                                                          */
/* This function adds a bulk placard to the storage area                    */
/* specified by intStorageArea with the class specified by                  */
/* intClass, subrisk specified by intSubRisk1 and                           */
/* intSubRisk2t, name specified by strName, UN number                       */
/* specified by strUN, hazchem specified by strHazchem and                  */
/* exemption specified by strExempt.                                        */
/*                                                                          */
/* INPUTS : int, int                                                        */
/* OUTPUTS: none                                                            */
/* **************************************************************************/

function addBulkPlacard(intStorageArea, intClass, intSubrisk1, intSubrisk2,
        strName, strUN, strHazchem, strExempt, intStorageType) {
    var intArrayLength = aBulkPlacard.length;
    aBulkPlacard[intArrayLength] = new Array(intBulkPlacardFC);
    aBulkPlacard[intArrayLength][eBPAStorageArea] = intStorageArea;
    aBulkPlacard[intArrayLength][eBPAClass] = intClass;
    aBulkPlacard[intArrayLength][eBPASubrisk1] = intSubrisk1;
    aBulkPlacard[intArrayLength][eBPASubrisk2] = intSubrisk2;
    aBulkPlacard[intArrayLength][eBPAName] = strName;
    aBulkPlacard[intArrayLength][eBPAUN] = strUN;
    aBulkPlacard[intArrayLength][eBPAHazchem] = strHazchem;
    aBulkPlacard[intArrayLength][eBPAExempt] = strExempt;
    aBulkPlacard[intArrayLength][eBPAStorageType] = intStorageType;
}



/* Function: placardRequired(intArea)                      */
/* This function returns true if a placard is needed for   */
/* the storage area specified by intArea.                  */
/* Mixed placards are ignored.                             */
/* INPUTS : int                                            */
/* OUTPUTS: none                                           */
function placardRequired(intArea) {
    var blnPlacard = false;
    for(idx=0; idx<aAreaPlacard.length; idx++) {
        if(aAreaPlacard[idx][eAPRStorageArea] == intArea) {
            for(idxField=1; idxField<intAreaPlacardFC; idxField++) {
                if(idxField != eAPRMixedClass && aAreaPlacard[idx][idxField]) {
                    blnPlacard = true;
                    break;
                }
            }
        }
    }
    return blnPlacard;
}



/* Function: checkForOtherDGs(pintPremise)                 */
/* This function checks for any existing goods that have a */
/* quantity larger than 0 and returns a count of this. It  */
/* only checks the storage area specified by pintPremise.  */
/* INPUTS : int                                            */
/* OUTPUTS: int                                            */
function checkForOtherDGs(pintPremise) {
    var intCount = 0;
    // find row for that premise
    for(intidx=0; intidx<aAreaTotal.length; intidx++) {
        if(aAreaTotal[intidx][eATAStorageArea]==pintPremise) {
            // found row check qtys
            for(intidy=0; intidy<intAreaTotalFC; intidy++) {
                if(intidy==eATAClass21 || intidy==eATAClass22Sub51 ||
                        intidy==eATAClass22SubNot51 || intidy==eATAClass23 ||
                        intidy==eATAClass3Pack1 || intidy==eATAClass3Pack2 ||
                        intidy==eATAClass3Pack3 || intidy==eATAClass41Pack1 ||
                        intidy==eATAClass41Pack2 || intidy==eATAClass41Pack3 ||
                        intidy==eATAClass42Pack1 || intidy==eATAClass42Pack2 ||
                        intidy==eATAClass42Pack3 || intidy==eATAClass43Pack1 ||
                        intidy==eATAClass43Pack2 || intidy==eATAClass43Pack3 ||
                        intidy==eATAClass51Pack1 || intidy==eATAClass51Pack2 ||
                        intidy==eATAClass51Pack3 || intidy==eATAClass52Pack1 ||
                        intidy==eATAClass52Pack2 || intidy==eATAClass52Pack3 ||
                        intidy==eATAClass61Pack1 || intidy==eATAClass61Pack2 ||
                        intidy==eATAClass61Pack3 || intidy==eATAClass8Pack1 ||
                        intidy==eATAClass8Pack2 || intidy==eATAClass8Pack3 ||
                        intidy==eATAClass9Pack2 || intidy==eATAClass9Pack3 ||
                        intidy==eATASubrisk21 || intidy==eATASubrisk22 ||
                        intidy==eATASubrisk23 || intidy==eATASubrisk3 ||
                        intidy==eATASubrisk41 || intidy==eATASubrisk42 ||
                        intidy==eATASubrisk43 || intidy==eATASubrisk51 ||
                        intidy==eATASubrisk52 || intidy==eATASubrisk61 ||
                        intidy==eATASubrisk8 || intidy==eATASubrisk9 ||
                        intidy==eATAGTDTT || intidy==eATAC1Bulk ||
                        intidy==eATAC1Packaged || intidy==eATAC2Bulk || intidy == eATAC1PackagedNotIsolated || intidy == eATAC1BulkNotIsolated ||
                        intidy==eATAC2Packaged || intidy==eATAClass1) {
                    if(aAreaTotal[intidx][intidy] > 0) {
                        intCount++;
                    }
                }
            }
        }
    }
    return intCount;
}



/* Function: checkForAeros(pintPremise)                    */
/* This function checks for any aerosols that have a       */
/* quantity larger than 0 and returns a count of this. It  */
/* only checks the storage area specified by pintPremise.  */
/* INPUTS : int                                            */
/* OUTPUTS: int                                            */
function checkForAeros(pintPremise) {
    var intCount = 0;
    // find row for that premise
    for(var intidx=0; intidx<aAreaTotal.length; intidx++) {
        if(aAreaTotal[intidx][eATAStorageArea] == pintPremise) {
            // found row check qtys
            for(var intidy=0; intidy<intAreaTotalFC; intidy++) {
                if(intidy==eATAClassA21 || intidy == eATAClassA22 ||
                        intidy==eATAClassA2251 || intidy == eATAClassA23) {
                    if(aAreaTotal[intidx][intidy] > 0) {
                        intCount++;
                    }
                }
            }
        }
    }
    return intCount;
}



/* Function: checkForCryos(pintPremise)                    */
/* This function checks for any cryogenics that have a     */
/* quantity larger than 0 and returns a count of this. It  */
/* only checks the storage area specified by pintPremise.  */
/* INPUTS : int                                            */
/* OUTPUTS: int                                            */
function checkForCryos(pintPremise) {
    var intCount = 0;
    // find row for that premise
    for(var intidx=0; intidx<aAreaTotal.length; intidx++) {
        if(aAreaTotal[intidx][eATAStorageArea]==pintPremise) {
            // found row check qtys
            for(var intidy=0; intidy<intAreaTotalFC; intidy++) {
                if(intidy == eATAClassC21 || intidy == eATAClassC22 ||
                        intidy == eATAClassC2251 || intidy == eATAClassC23) {
                    if(aAreaTotal[intidx][intidy] > 0) {
                        intCount++;
                    }
                }
            }
        }
    }
    return intCount;
}

/* Function: loadGoodsLocally()                            */
/* This function loads all the goods into the local goods  */
/* array.                                                  */
/* INPUTS : none                                           */
/* OUTPUTS: none                                           */
function loadGoodsLocally(caller) {
    quantityGrandTotal = 0; // reset
    for(j = 0; j < numGoods; j++) {
        if(aGoods[j]!=null) {
            addToGrandTotalArray(aGoods[j]);
	    quantityGrandTotal  += parseInt(aGoods[j][eGAQuantity]);
        }
    }
}



/* Function: loadGoodsIntoPremises()                       */
/* This function loads each good into its appropriate      */
/* storage area for the grand total array as well as the   */
/* area total array.                                       */
/* It also creates bulk placards if needed.                */
/* INPUTS : none                                           */
/* OUTPUTS: none                                           */
function loadGoodsIntoPremises() {
    for(idxPremise=0; idxPremise<numPremises; idxPremise++) {
        for(idxGood=0; idxGood<numGoods; idxGood++) {
            if(aGrandTotal.length>0) {
                // allow for exempt goods
                if(aGrandTotal[idxGood][eGTAStorageArea] == idxPremise) {
                    // Check class
                    var intClassIdx = -1;
                    var blnFireRisk = false;
                    switch(aGrandTotal[idxGood][eGTAClass]) {
                        case Class_2_1:
                            intClassIdx = eATAClass21; blnFireRisk = true;
                            break;
                        case Class_2_1_A:
                            intClassIdx = eATAClassA21;
                            blnFireRisk = true;
                            break;
                        case Class_2_1_C:
                            intClassIdx = eATAClassC21;
                            blnFireRisk = true;
                            break;
                        case Class_2_2:
                            if(aGrandTotal[idxGood][eGTASubrisk1] == Class_5_1 ||
                                    aGrandTotal[idxGood][eGTASubrisk2] == Class_5_1) {
                                intClassIdx = eATAClass22Sub51; blnFireRisk = true;
                            } else {
                                intClassIdx = eATAClass22SubNot51;
                            }
                            break;
                        case Class_2_1_A:
                            if(aGrandTotal[idxGood][eGTASubrisk1] == Class_5_1 ||
                                    aGrandTotal[idxGood][eGTASubrisk2] == Class_5_1) {
                                intClassIdx = eATAClassA2251;
                            } else {
                                intClassIdx = eATAClassA22;
                            }
                            break;
                        case Class_2_2_C:
                            if(aGrandTotal[idxGood][eGTASubrisk1] == Class_5_1 ||
                                    aGrandTotal[idxGood][eGTASubrisk2] == Class_5_1) {
                                intClassIdx = eATAClassC2251;
                            } else {
                                intClassIdx = eATAClassC22;
                            }
                            break;
                        case Class_2_3:
                            intClassIdx = eATAClass23;
                            break;
                        case Class_2_1_A:
                            intClassIdx = eATAClassA23;
                            break;
                        case Class_2_3_C:
                            intClassIdx = eATAClassC23;
                            break;
                        case Class_3:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass3Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass3Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass3Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass3Pack3; break;
                            }
                            blnFireRisk = true; break;
                        case Class_4_1:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass41Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass41Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass41Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass41Pack3; break;
                            }
                            blnFireRisk = true; break;
                        case Class_4_2:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass42Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass42Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass42Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass42Pack3; break;
                            }
                            blnFireRisk = true; break;
                        case Class_4_3:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass43Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass43Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass43Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass43Pack3; break;
                            }
                            blnFireRisk = true; break;
                        case Class_5_1:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass51Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass51Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass51Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass51Pack3; break;
                            }
                            blnFireRisk = true; break;
                        case Class_5_2:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass52Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass52Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass52Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass52Pack3; break;
                            }
                            blnFireRisk = true; break;
                        case Class_6_1:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass61Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass61Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass61Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass61Pack3; break;
                            }
                            break;
                        case Class_8:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I:
                                    intClassIdx = eATAClass8Pack1; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass8Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass8Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass8Pack3; break;
                            }
                            break;
                        case Class_9:
                            switch(aGrandTotal[idxGood][eGTAPackingGroup]) {
                                case packingGroup_I: // not allowed, default to 3
                                    intClassIdx = eATAClass9Pack3; break;
                                case packingGroup_II:
                                    intClassIdx = eATAClass9Pack2; break;
                                case packingGroup_III:
                                    intClassIdx = eATAClass9Pack3; break;
                                case packingGroup_none: // not allowed, default to 3
                                    intClassIdx = eATAClass9Pack3; break;
                            }
                            break;
                        case GoodsTooDangerous: intClassIdx = eATAGTDTT; break;
                        case C1:
                            if(aGrandTotal[idxGood][eGTAStorageType] == ePacking_Bulk) {
                                if (aGrandTotal[idxGood][eGTAC1Isolated] == 'true') {
                                    intClassIdx = eATAC1Bulk;
                                } else {
                                    intClassIdx = eATAC1BulkNotIsolated;
                                }
                            } else {
                                if (aGrandTotal[idxGood][eGTAC1Isolated] == 'true') {
                                    intClassIdx = eATAC1Packaged;
                                } else {
                                    intClassIdx = eATAC1PackagedNotIsolated;
                                }
                            }
                            break;
                        case C2:
                            if (aGrandTotal[idxGood][eGTAStorageType] == ePacking_Bulk) {
                                intClassIdx = eATAC2Bulk;
                            } else {
                                intClassIdx = eATAC2Packaged;
                            }
                            break;
                        case Class_1:
                            intClassIdx = eATAClass1;
                            //blnFireRisk = true;
                            break;
                    }
                    // Check subrisk1
                    var intSubrisk1Idx = -1;
                    switch (aGrandTotal[idxGood][eGTASubrisk1]) {
                        case Class_2_1:
                            intSubrisk1Idx = eATASubrisk21;
                            blnFireRisk = true;
                            break;
                        case Class_2_2:
                            intSubrisk1Idx = eATASubrisk22;
                            break;
                        case Class_2_3:
                            intSubrisk1Idx = eATASubrisk23;
                            break;
                        case Class_3:
                            intSubrisk1Idx = eATASubrisk3;
                            blnFireRisk = true;
                            break;
                        case Class_4_1:
                            intSubrisk1Idx = eATASubrisk41;
                            blnFireRisk = true;
                            break;
                        case Class_4_2:
                            intSubrisk1Idx = eATASubrisk42;
                            blnFireRisk = true;
                            break;
                        case Class_4_3:
                            intSubrisk1Idx = eATASubrisk43;
                            blnFireRisk = true;
                            break;
                        case Class_5_1:
                            intSubrisk1Idx = eATASubrisk51;
                            blnFireRisk = true;
                            break;
                        case Class_6_1:
                            intSubrisk1Idx = eATASubrisk61;
                            break;
                        case Class_8:
                            intSubrisk1Idx = eATASubrisk8;
                            break;
                        case Class_9:
                            intSubrisk1Idx = eATASubrisk9;
                            break;
                        case Class_1:
                            intSubrisk1Idx = eATASubrisk1;
                            break;
                    }
                    // Check subrisk2
                    var intSubrisk2Idx = -1;
                    switch (aGrandTotal[idxGood][eGTASubrisk2]) {
                        case Class_2_1:
                            intSubrisk2Idx = eATASubrisk21;
                            blnFireRisk = true;
                            break;
                        case Class_2_2:
                            intSubrisk2Idx = eATASubrisk22;
                            break;
                        case Class_2_3:
                            intSubrisk2Idx = eATASubrisk23;
                            break;
                        case Class_3:
                            intSubrisk2Idx = eATASubrisk3;
                            blnFireRisk = true;
                            break;
                        case Class_4_1:
                            intSubrisk2Idx = eATASubrisk41;
                            blnFireRisk = true;
                            break;
                        case Class_4_2:
                            intSubrisk2Idx = eATASubrisk42;
                            blnFireRisk = true;
                            break;
                        case Class_4_3:
                            intSubrisk2Idx = eATASubrisk43;
                            blnFireRisk = true;
                            break;
                        case Class_5_1:
                            intSubrisk2Idx = eATASubrisk51;
                            blnFireRisk = true;
                            break;
                        case Class_6_1:
                            intSubrisk2Idx = eATASubrisk61;
                            break;
                        case Class_8:
                            intSubrisk2Idx = eATASubrisk8;
                            break;
                        case Class_9:
                            intSubrisk2Idx = eATASubrisk9;
                            break;
                        case Class_1:
                            intSubrisk2Idx = eATASubrisk1;
                            break;
                    }
                    addToAreaTotalArray(idxPremise, aGrandTotal[idxGood][eGTAQuantity], intClassIdx);
                    addToAreaTotalArray(idxPremise, aGrandTotal[idxGood][eGTAQuantity], intSubrisk1Idx);
                    addToAreaTotalArray(idxPremise, aGrandTotal[idxGood][eGTAQuantity], intSubrisk2Idx);
                    addToAreaTotalArray(idxPremise, blnFireRisk, eATAHasFireRisk);

                    /* Use eAPR here because we're adding a area placard reason APR, not area total ATA */
                    if (aGrandTotal[idxGood][eGTAStorageType] == ePacking_Bulk ||
                        aGrandTotal[idxGood][eGTAStorageType] == ePacking_IBC ) {
                        if (intClassIdx == eATAClassAero || intClassIdx==eATAClassCryo) {
                            switch (aGrandTotal[idxGood][eGTAClass]) {
                                case Class_2_1:
                                     intClassIdx = eAPRClass21;
                                    break;
                                case Class_2_2:
                                     intClassIdx = eAPRClass22;
                                    break;
                                case Class_2_3:
                                     intClassIdx = eAPRClass23;
                                    break;
                                case Class_3:
                                     intClassIdx = eAPRClass3;
                                    break;
                                case Class_4_1:
                                     intClassIdx = eAPRClass41;
                                    break;
                                case Class_4_2:
                                     intClassIdx = eAPRClass42;
                                    break;
                                case Class_4_3:
                                     intClassIdx = eAPRClass43;
                                    break;
                                case Class_5_1:
                                     intClassIdx = eAPRClass51;
                                    break;
                                case Class_6_1:
                                     intClassIdx = eAPRClass61;
                                    break;
                                case Class_8:
                                     intClassIdx = eAPRClass8;
                                    break;
                                case Class_9:
                                     intClassIdx = eAPRClass9;
                                    break;
                                case Class_1:
                                     intClassIdx = eAPRClass1;
                                    break;
                            } // end switch (aGrandTotal[idxGood][eGTAClass])
                        } // end if (intClassIdx == eATAClassAero ||...
                        // C2 does not trigger a bulk placard ever
                        if((intClassIdx != eATAC2Bulk) && (intClassIdx != eATAC2Packaged)) {
							addBulkPlacard(idxPremise, intClassIdx, intSubrisk1Idx, intSubrisk2Idx,
									aGrandTotal[idxGood][eGTAName], aGrandTotal[idxGood][eGTAUN],
									aGrandTotal[idxGood][eGTAHazchem],
									aGrandTotal[idxGood][eGTAExempt],
									aGrandTotal[idxGood][eGTAStorageType])
						}
                    } // end if (aGrandTotal[idxGood][eGTAStorageType] == ePacking_Bulk)
                }
            }
        }
    }
}



/* Function: checkAreaPlacarding(intPremise)               */
/* This function checks the storage area specified by      */
/* intPremise for the placarding levels of items 1-7 of    */
/* schedule. It does not check Regulations 39.2.b or 39.2.c.   */
/* INPUTS : int                                            */
/* OUTPUTS: none                                           */
function checkAreaPlacarding(intPremise) {
    var intItem6Qty=0;
    var intDGCount = checkForOtherDGs(intPremise);
    var intAeroCount = checkForAeros(intPremise);
    var intCryoCount = checkForCryos(intPremise);
    var intCryoTotal = 0;
    var blnHasC = false;
    var blnAeroPlacard = false;
    var blnCryoPlacard = false;
    var blnC1Isolated = true;
    /* ITEM 1 */
    // 2.1
    if(aAreaTotal[intPremise][eATAClass21] > aSchedulePlacardLimit[eItem1_Class21]) {
        addToAreaPlacardArray(intPremise, true, eAPRClass21, strReasonItem1);
    }
    // 2.2Sub5.1
    if(aAreaTotal[intPremise][eATAClass22Sub51] > aSchedulePlacardLimit[eItem1_Class22Sub51]) {
        addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51, strReasonItem1);
    }
    // 2.2 Other
    if(aAreaTotal[intPremise][eATAClass22SubNot51] > aSchedulePlacardLimit[eItem1_Class22Other]) {
        addToAreaPlacardArray(intPremise, true, eAPRClass22, strReasonItem1);
    }
    // 2.3
    if(aAreaTotal[intPremise][eATAClass23] > aSchedulePlacardLimit[eItem1_Class23]) {
        addToAreaPlacardArray(intPremise, true, eAPRClass23, strReasonItem1);
    }

    // check total aeros > limit
    if(aAreaTotal[intPremise][eATAClassA21]+aAreaTotal[intPremise][eATAClassA22]+aAreaTotal[intPremise][eATAClassA2251]+aAreaTotal[intPremise][eATAClassA23] > aSchedulePlacardLimit[eItem1_Class2A]) {
        if(aAreaTotal[intPremise][eATAClassA21]>aSchedulePlacardLimit[eItem1_Class2A]) {
            addToAreaPlacardArray(intPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule1+" (Aerosol)")
            blnAeroPlacard=true;
        }
        else if(aAreaTotal[intPremise][eATAClassA21]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            addToAreaPlacardArray(intPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule1+" (Aerosol 50%)")
            blnAeroPlacard=true;
        }
        if(aAreaTotal[intPremise][eATAClassA22]>aSchedulePlacardLimit[eItem1_Class2A]) {
            addToAreaPlacardArray(intPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule1+" (Aerosol)")
            blnAeroPlacard=true;
        }
        else if(aAreaTotal[intPremise][eATAClassA22]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            addToAreaPlacardArray(intPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule1+" (Aerosol 50%)")
            blnAeroPlacard=true;
        }
        if(aAreaTotal[intPremise][eATAClassA2251]>aSchedulePlacardLimit[eItem1_Class2A]) {
            addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51, strReasonAeroCryo);//strReasonRule1+" (Aerosol)")
            blnAeroPlacard=true;
        }
        else if(aAreaTotal[intPremise][eATAClassA2251]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51, strReasonAeroCryo);//strReasonRule1+" (Aerosol 50%)")
            blnAeroPlacard=true;
        }
        if(aAreaTotal[intPremise][eATAClassA23]>aSchedulePlacardLimit[eItem1_Class2A]) {
            addToAreaPlacardArray(intPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule1+" (Aerosol)")
            blnAeroPlacard=true;
        }
        else if(aAreaTotal[intPremise][eATAClassA23]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            addToAreaPlacardArray(intPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule1+" (Aerosol 50%)")
            blnAeroPlacard=true;
        }
        if(intAeroCount>1 && !blnAeroPlacard) { // add mixed class placard
            addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonAeroCryo);//strReasonRule1+" (Mixed Aerosols)")
        }
    }
    // check total cryos > limit
    intCryoTotal = aAreaTotal[intPremise][eATAClassC21]+aAreaTotal[intPremise][eATAClassC22]+aAreaTotal[intPremise][eATAClassC2251]+aAreaTotal[intPremise][eATAClassC23];
    if((intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C]) && (aAreaTotal[intPremise][eATAClassC21]>aSchedulePlacardLimit[eItem1_Class2C])) {
        addToAreaPlacardArray(intPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule2+" (Cryogenics)")
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aAreaTotal[intPremise][eATAClassC21]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        addToAreaPlacardArray(intPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule2+" (Cryogenics 50%)")
        blnCryoPlacard=true;
    }
    if((intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C]) && (aAreaTotal[intPremise][eATAClassC22]>aSchedulePlacardLimit[eItem1_Class2C])) {
        addToAreaPlacardArray(intPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule2+" (Cryogenics)")
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aAreaTotal[intPremise][eATAClassC22]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        addToAreaPlacardArray(intPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule2+" (Cryogenics 50%)")
        blnCryoPlacard=true;
    }
    if((intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C]) && (aAreaTotal[intPremise][eATAClassC2251]>aSchedulePlacardLimit[eItem1_Class2C])) {
        addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51, strReasonAeroCryo);//strReasonRule2+" (Cryogenics)")
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aAreaTotal[intPremise][eATAClassC2251]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        addToAreaPlacardArray(intPremise, true, eAPRClass22Sub51, strReasonAeroCryo);//strReasonRule2+" (Cryogenics 50%)")
        blnCryoPlacard=true;
    }
    if((intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C]) && (aAreaTotal[intPremise][eATAClassC23]>aSchedulePlacardLimit[eItem1_Class2C])) {
        addToAreaPlacardArray(intPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule2+" (Cryogenics)")
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aAreaTotal[intPremise][eATAClassC23]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        addToAreaPlacardArray(intPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule2+" (Cryogenics 50%)")
        blnCryoPlacard=true;
    }
    if(intCryoCount>1 && !blnCryoPlacard && intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C] && intCryoTotal<=aSchedulePlacardLimit[eItem4a]) {
        // add mixed class placard
        addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonAeroCryo);//strReasonRule2+" (Mixed Cryogenics)")
    }
    /* END ITEM 1 */
    /* ITEM 2 */
    // 3
    if(aAreaTotal[intPremise][eATAClass3Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass3, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass3Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass3, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass3Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass3, strReasonItem2)
    if(((aAreaTotal[intPremise][eATAClass3Pack1]+aAreaTotal[intPremise][eATAClass3Pack2]+aAreaTotal[intPremise][eATAClass3Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) && !aAreaPlacard[intPremise][eAPRClass3]) addToAreaPlacardArray(intPremise, true, eAPRClass3, strReasonItem2)
    // 4
    if(aAreaTotal[intPremise][eATAClass41Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass41, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass41Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass41, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass41Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass41, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass41Pack1]+aAreaTotal[intPremise][eATAClass41Pack2]+aAreaTotal[intPremise][eATAClass41Pack3]) > aSchedulePlacardLimit[eItem2_PackM])  addToAreaPlacardArray(intPremise, true, eAPRClass41, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass42Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass42, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass42Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass42, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass42Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass42, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass42Pack1]+aAreaTotal[intPremise][eATAClass42Pack2]+aAreaTotal[intPremise][eATAClass42Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass42, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass43Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass43, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass43Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass43, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass43Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass43, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass43Pack1]+aAreaTotal[intPremise][eATAClass43Pack2]+aAreaTotal[intPremise][eATAClass43Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass43, strReasonItem2)
    // 5
    if(aAreaTotal[intPremise][eATAClass51Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass51, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass51Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass51, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass51Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass51, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass51Pack1]+aAreaTotal[intPremise][eATAClass51Pack2]+aAreaTotal[intPremise][eATAClass51Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass51, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass52Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass52, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass52Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass52, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass52Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass52, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass52Pack1]+aAreaTotal[intPremise][eATAClass52Pack2]+aAreaTotal[intPremise][eATAClass52Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass52, strReasonItem2)
    // 6
    if(aAreaTotal[intPremise][eATAClass61Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass61, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass61Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass61, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass61Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass61, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass61Pack1]+aAreaTotal[intPremise][eATAClass61Pack2]+aAreaTotal[intPremise][eATAClass61Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass61, strReasonItem2)
    // 8
    if(aAreaTotal[intPremise][eATAClass8Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) addToAreaPlacardArray(intPremise, true, eAPRClass8, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass8Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass8, strReasonItem2)
    if(aAreaTotal[intPremise][eATAClass8Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass8, strReasonItem2)
    if((aAreaTotal[intPremise][eATAClass8Pack1]+aAreaTotal[intPremise][eATAClass8Pack2]+aAreaTotal[intPremise][eATAClass8Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass8, strReasonItem2)
    /* END ITEM 2 */
    /* ITEM 3 */
    // 9
    if(aAreaTotal[intPremise][eATAClass9Pack2] > aSchedulePlacardLimit[eItem3_Pack2]) addToAreaPlacardArray(intPremise, true, eAPRClass9, strReasonItem3)
    if(aAreaTotal[intPremise][eATAClass9Pack3] > aSchedulePlacardLimit[eItem3_Pack3]) addToAreaPlacardArray(intPremise, true, eAPRClass9, strReasonItem3)
    if((aAreaTotal[intPremise][eATAClass9Pack2]+aAreaTotal[intPremise][eATAClass9Pack3]) > aSchedulePlacardLimit[eItem3_PackM]) addToAreaPlacardArray(intPremise, true, eAPRClass9, strReasonItem3)
    /* ITEM 3 */
    /* Item 6 */
    // GTDTT
    if(aAreaTotal[intPremise][eATAGTDTT] > aSchedulePlacardLimit[eItem6]) addToAreaPlacardArray(intPremise, true, eAPRGTDTT, strReasonItem5)
    /* END Item 6 */
    /* Item 5 */
    // C1s, C2s and any FireRisks
    if(aGrandTotal.length>0) {
        for(intAA=0; intAA<numGoods; intAA++) {
            if(aGrandTotal[intAA][eGTAStorageArea]==intPremise) {
		if(aGrandTotal[intAA][eGTAClass]==C1) {
                    intItem6Qty+=aGrandTotal[intAA][eGTAQuantity];
                    blnHasC = true;
                } else if(aGrandTotal[intAA][eGTAClass]==C2) {
                    intItem6Qty+=aGrandTotal[intAA][eGTAQuantity];
                    blnHasC = true;
		    blnC1Isolated = false;
		} else {
			blnC1Isolated = false;
			if(aGrandTotal[intAA][eGTAIsFireRisk]==true) {
				intItem6Qty+=aGrandTotal[intAA][eGTAQuantity];
			}
		}
            }
        }
    }
    if((intItem6Qty > aSchedulePlacardLimit[eItem5]) && aAreaTotal[intPremise][eATAHasFireRisk] == 1 && blnHasC) {
        //alert("Item 5: " + intItem6Qty + "\nplac: " + aSchedulePlacardLimit[eItem5] + "\nhasFR: " + aAreaTotal[intPremise][eATAHasFireRisk] + "\nblnHasC: " + blnHasC);
        addToAreaPlacardArray(intPremise, true, eAPRClass3, strReasonItem6, true)
    }
    /* END Item 5 */
    /* ITEM 7 */
    // C1
    if(blnC1Isolated) {
		// goods not marked as isolated are isolated by the
		// fact they are not stored with any other DGs
		if((aAreaTotal[intPremise][eATAC1Bulk]+aAreaTotal[intPremise][eATAC1BulkNotIsolated]) > aSchedulePlacardLimit[eItem7_Bulk]) addToAreaPlacardArray(intPremise, true, eAPRCombustibleLiquids, strReasonItem7)
		else if((aAreaTotal[intPremise][eATAC1Packaged]+aAreaTotal[intPremise][eATAC1PackagedNotIsolated]) > aSchedulePlacardLimit[eItem7_Pack]) addToAreaPlacardArray(intPremise, true, eAPRCombustibleLiquids, strReasonItem7)
		else if((aAreaTotal[intPremise][eATAC1Bulk]+aAreaTotal[intPremise][eATAC1BulkNotIsolated]+aAreaTotal[intPremise][eATAC1Packaged]+aAreaTotal[intPremise][eATAC1PackagedNotIsolated]) > aSchedulePlacardLimit[eItem7_BulkPack]) addToAreaPlacardArray(intPremise, true, eAPRCombustibleLiquids, strReasonItem7)
	}
	else {
		if(aAreaTotal[intPremise][eATAC1Bulk] > aSchedulePlacardLimit[eItem7_Bulk]) addToAreaPlacardArray(intPremise, true, eAPRCombustibleLiquids, strReasonItem7)
		else if(aAreaTotal[intPremise][eATAC1Packaged] > aSchedulePlacardLimit[eItem7_Pack]) addToAreaPlacardArray(intPremise, true, eAPRCombustibleLiquids, strReasonItem7)
		else if((aAreaTotal[intPremise][eATAC1Bulk]+aAreaTotal[intPremise][eATAC1Packaged]) > aSchedulePlacardLimit[eItem7_BulkPack]) addToAreaPlacardArray(intPremise, true, eAPRCombustibleLiquids, strReasonItem7)
	}
    /* END ITEM 7 */

    /* special Regulation for subrisk 1 DGs */
    if(aAreaTotal[intPremise][eATAClass1] >= 1 || aAreaTotal[intPremise][eATASubrisk1] >= 1) addToAreaPlacardArray(intPremise, true, eAPRClass1, "State or Territory legislation")
    /* end special Regulation */

    /* ITEM 4 */
    if(!placardRequired(intPremise)) {
        // 2000 limit
        var int2000Amount = 0;
        // check for Aero Cryo special Rules
        var blnAero = false, blnCryo = false, blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass21] > 0) || (aAreaTotal[intPremise][eATAClass22Sub51] > 0) || (aAreaTotal[intPremise][eATAClass22SubNot51] > 0) || (aAreaTotal[intPremise][eATAClass23] > 0))
            blnClass2Only = true;
        if((aAreaTotal[intPremise][eATAClassA21] > 0) || (aAreaTotal[intPremise][eATAClassA22] > 0) || (aAreaTotal[intPremise][eATAClassA2251] > 0) || (aAreaTotal[intPremise][eATAClassA23] > 0))
            blnAero = true;
        if((aAreaTotal[intPremise][eATAClassC21] > 0) || (aAreaTotal[intPremise][eATAClassC22] > 0) || (aAreaTotal[intPremise][eATAClassC2251] > 0) || (aAreaTotal[intPremise][eATAClassC23] > 0))
            blnCryo = true;
        if((aAreaTotal[intPremise][eATAClass3Pack1] > 0) || (aAreaTotal[intPremise][eATAClass3Pack2] > 0) || (aAreaTotal[intPremise][eATAClass3Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass41Pack1] > 0) || (aAreaTotal[intPremise][eATAClass41Pack2] > 0) || (aAreaTotal[intPremise][eATAClass41Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass42Pack1] > 0) || (aAreaTotal[intPremise][eATAClass42Pack2] > 0) || (aAreaTotal[intPremise][eATAClass42Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass43Pack1] > 0) || (aAreaTotal[intPremise][eATAClass43Pack2] > 0) || (aAreaTotal[intPremise][eATAClass43Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass51Pack1] > 0) || (aAreaTotal[intPremise][eATAClass51Pack2] > 0) || (aAreaTotal[intPremise][eATAClass51Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass52Pack1] > 0) || (aAreaTotal[intPremise][eATAClass52Pack2] > 0) || (aAreaTotal[intPremise][eATAClass52Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass61Pack1] > 0) || (aAreaTotal[intPremise][eATAClass61Pack2] > 0) || (aAreaTotal[intPremise][eATAClass61Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass8Pack1] > 0) || (aAreaTotal[intPremise][eATAClass8Pack2] > 0) || (aAreaTotal[intPremise][eATAClass8Pack3] > 0))
            blnClass2Only = false;
        if((aAreaTotal[intPremise][eATAClass9Pack2] > 0) || (aAreaTotal[intPremise][eATAClass9Pack3] > 0))
            blnClass2Only = false;

        if(!aAreaPlacard[intPremise][eAPRClass21] && aSchedulePlacardLimit[eItem1_Class21] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClass21];
        if(!aAreaPlacard[intPremise][eAPRClass22Sub51] && aSchedulePlacardLimit[eItem1_Class22Sub51] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClass22Sub51];
        if(!aAreaPlacard[intPremise][eAPRClass22] && aSchedulePlacardLimit[eItem1_Class22Other] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClass22SubNot51];
        if(!aAreaPlacard[intPremise][eAPRClass23] && aSchedulePlacardLimit[eItem1_Class23] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClass23];
        // aeros
        if(!aAreaPlacard[intPremise][eAPRClass21] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassA21];
        if(!aAreaPlacard[intPremise][eAPRClass22] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassA22];
        if(!aAreaPlacard[intPremise][eAPRClass22Sub51] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassA2251];
        if(!aAreaPlacard[intPremise][eAPRClass23] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassA23];
        // cryos
        if(!aAreaPlacard[intPremise][eAPRClass21] && aSchedulePlacardLimit[eItem1_Class2C] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassC21];
        if(!aAreaPlacard[intPremise][eAPRClass22] && aSchedulePlacardLimit[eItem1_Class2C] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassC22];
        if(!aAreaPlacard[intPremise][eAPRClass22Sub51] && aSchedulePlacardLimit[eItem1_Class2C] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassC2251];
        if(!aAreaPlacard[intPremise][eAPRClass23] && aSchedulePlacardLimit[eItem1_Class2C] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClassC23];
        if(aSchedulePlacardLimit[eItem2_Pack1] <= aSchedulePlacardLimit[eItem4a]) {
            if(!aAreaPlacard[intPremise][eAPRClass3]) int2000Amount += aAreaTotal[intPremise][eATAClass3Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass41]) int2000Amount += aAreaTotal[intPremise][eATAClass41Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass42]) int2000Amount += aAreaTotal[intPremise][eATAClass42Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass43]) int2000Amount += aAreaTotal[intPremise][eATAClass43Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass51]) int2000Amount += aAreaTotal[intPremise][eATAClass51Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass52]) int2000Amount += aAreaTotal[intPremise][eATAClass52Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass61]) int2000Amount += aAreaTotal[intPremise][eATAClass61Pack1];
            if(!aAreaPlacard[intPremise][eAPRClass8]) int2000Amount += aAreaTotal[intPremise][eATAClass8Pack1];
        }
        if(aSchedulePlacardLimit[eItem2_Pack2] <= aSchedulePlacardLimit[eItem4a]) {
            if(!aAreaPlacard[intPremise][eAPRClass3]) int2000Amount += aAreaTotal[intPremise][eATAClass3Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass41]) int2000Amount += aAreaTotal[intPremise][eATAClass41Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass42]) int2000Amount += aAreaTotal[intPremise][eATAClass42Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass43]) int2000Amount += aAreaTotal[intPremise][eATAClass43Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass51]) int2000Amount += aAreaTotal[intPremise][eATAClass51Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass52]) int2000Amount += aAreaTotal[intPremise][eATAClass52Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass61]) int2000Amount += aAreaTotal[intPremise][eATAClass61Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass8]) int2000Amount += aAreaTotal[intPremise][eATAClass8Pack2];
        }
        if(aSchedulePlacardLimit[eItem2_Pack3] <= aSchedulePlacardLimit[eItem4a]) {
            if(!aAreaPlacard[intPremise][eAPRClass3]) int2000Amount += aAreaTotal[intPremise][eATAClass3Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass41]) int2000Amount += aAreaTotal[intPremise][eATAClass41Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass42]) int2000Amount += aAreaTotal[intPremise][eATAClass42Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass43]) int2000Amount += aAreaTotal[intPremise][eATAClass43Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass51]) int2000Amount += aAreaTotal[intPremise][eATAClass51Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass52]) int2000Amount += aAreaTotal[intPremise][eATAClass52Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass61]) int2000Amount += aAreaTotal[intPremise][eATAClass61Pack3];
            if(!aAreaPlacard[intPremise][eAPRClass8]) int2000Amount += aAreaTotal[intPremise][eATAClass8Pack3];
        }
        if(!aAreaPlacard[intPremise][eAPRClass9] && aSchedulePlacardLimit[eItem3_Pack2] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClass9Pack2];
        if(!aAreaPlacard[intPremise][eAPRClass9] && aSchedulePlacardLimit[eItem3_Pack3] <= aSchedulePlacardLimit[eItem4a]) int2000Amount += aAreaTotal[intPremise][eATAClass9Pack3];
        addToAreaTotalArray(intPremise, int2000Amount, eATAMixed2000)
        if(aAreaTotal[intPremise][eATAMixed2000] > aSchedulePlacardLimit[eItem4a]) {
            if(!(blnAero || blnCryo)) {
                addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonItem4a)
            }
            else if(blnClass2Only) {
                addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonAeroCryo);//strReasonRule3 + "( Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
            }
            else {
                addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonAeroCryo);//strReasonRule4 + "( Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
            }
        }
        else {
            // 5000 limit
            var int5000Amount = 0;
            if(!aAreaPlacard[intPremise][eAPRClass21] && aSchedulePlacardLimit[eItem1_Class21] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClass21];
            if(!aAreaPlacard[intPremise][eAPRClass22Sub51] && aSchedulePlacardLimit[eItem1_Class22Sub51] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClass22Sub51];
            if(!aAreaPlacard[intPremise][eAPRClass22] && aSchedulePlacardLimit[eItem1_Class22Other] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClass22SubNot51];
            if(!aAreaPlacard[intPremise][eAPRClass23] && aSchedulePlacardLimit[eItem1_Class23] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClass23];
            // aeros
            if(!aAreaPlacard[intPremise][eAPRClass21] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassA21];
            if(!aAreaPlacard[intPremise][eAPRClass22] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassA22];
            if(!aAreaPlacard[intPremise][eAPRClass22Sub51] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassA2251];
            if(!aAreaPlacard[intPremise][eAPRClass23] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassA23];
            // cryos
            if(!aAreaPlacard[intPremise][eAPRClass21] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassC21];
            if(!aAreaPlacard[intPremise][eAPRClass22] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassC22];
            if(!aAreaPlacard[intPremise][eAPRClass22Sub51] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassC2251];
            if(!aAreaPlacard[intPremise][eAPRClass23] && aSchedulePlacardLimit[eItem1_Class2A] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClassC23];
            if(aSchedulePlacardLimit[eItem2_Pack1] <= aSchedulePlacardLimit[eItem4b]) {
                if(!aAreaPlacard[intPremise][eAPRClass3]) int5000Amount += aAreaTotal[intPremise][eATAClass3Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass41]) int5000Amount += aAreaTotal[intPremise][eATAClass41Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass42]) int5000Amount += aAreaTotal[intPremise][eATAClass42Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass43]) int5000Amount += aAreaTotal[intPremise][eATAClass43Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass51]) int5000Amount += aAreaTotal[intPremise][eATAClass51Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass52]) int5000Amount += aAreaTotal[intPremise][eATAClass52Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass61]) int5000Amount += aAreaTotal[intPremise][eATAClass61Pack1];
                if(!aAreaPlacard[intPremise][eAPRClass8]) int5000Amount += aAreaTotal[intPremise][eATAClass8Pack1];
            }
            if(aSchedulePlacardLimit[eItem2_Pack2] <= aSchedulePlacardLimit[eItem4b]) {
                if(!aAreaPlacard[intPremise][eAPRClass3]) int5000Amount += aAreaTotal[intPremise][eATAClass3Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass41]) int5000Amount += aAreaTotal[intPremise][eATAClass41Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass42]) int5000Amount += aAreaTotal[intPremise][eATAClass42Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass43]) int5000Amount += aAreaTotal[intPremise][eATAClass43Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass51]) int5000Amount += aAreaTotal[intPremise][eATAClass51Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass52]) int5000Amount += aAreaTotal[intPremise][eATAClass52Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass61]) int5000Amount += aAreaTotal[intPremise][eATAClass61Pack2];
                if(!aAreaPlacard[intPremise][eAPRClass8]) int5000Amount += aAreaTotal[intPremise][eATAClass8Pack2];
            }
            if(aSchedulePlacardLimit[eItem2_Pack3] <= aSchedulePlacardLimit[eItem4b]) {
                if(!aAreaPlacard[intPremise][eAPRClass3]) int5000Amount += aAreaTotal[intPremise][eATAClass3Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass41]) int5000Amount += aAreaTotal[intPremise][eATAClass41Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass42]) int5000Amount += aAreaTotal[intPremise][eATAClass42Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass43]) int5000Amount += aAreaTotal[intPremise][eATAClass43Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass51]) int5000Amount += aAreaTotal[intPremise][eATAClass51Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass52]) int5000Amount += aAreaTotal[intPremise][eATAClass52Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass61]) int5000Amount += aAreaTotal[intPremise][eATAClass61Pack3];
                if(!aAreaPlacard[intPremise][eAPRClass8]) int5000Amount += aAreaTotal[intPremise][eATAClass8Pack3];
            }
            if(!aAreaPlacard[intPremise][eAPRClass9] && aSchedulePlacardLimit[eItem3_Pack2] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClass9Pack2];
            if(!aAreaPlacard[intPremise][eAPRClass9] && aSchedulePlacardLimit[eItem3_Pack3] <= aSchedulePlacardLimit[eItem4b]) int5000Amount += aAreaTotal[intPremise][eATAClass9Pack3];
            addToAreaTotalArray(intPremise, int5000Amount, eATAMixed5000)
            if(aAreaTotal[intPremise][eATAMixed5000] > aSchedulePlacardLimit[eItem4b]) {
                if(!(blnAero || blnCryo)) {
                    addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonItem4b)
                }
                else if(blnClass2Only) {
                    addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonAeroCryo);//strReasonRule3 + " (Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                }
                else {
                    addToAreaPlacardArray(intPremise, true, eAPRMixedClass, strReasonAeroCryo);//strReasonRule4 + " (Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                }
            }
        }
    }
    /* END ITEM 4 */
}

/* Function: checkPremisesHazchem()                        */
/* This function totals the goods across the entire        */
/* premise and checks items 1-7 excluding 39.2.b and 29.2.c*/
/* INPUTS : none                                           */
/* OUTPUTS: none                                           */
function checkPremisesHazchem() {
    var intDGCount = 0;
    var intAeroCount = 0;
    var intCryoCount = 0;
    for(s=0; s<aAreaTotal.length; s++) {
        for(t=0; t<intAreaTotalFC; t++) {
            aPremiseTotal[t] += aAreaTotal[s][t];
        }
    }
    for(s=0; s<numPremises; s++) {
        intDGCount += checkForOtherDGs(s);
        intAeroCount += checkForAeros(s);
        intCryoCount += checkForCryos(s);
    }
    var intItem6Qty=0;
    var intCryoTotal = 0;
    var blnHasC = false;
    var blnAeroPlacard = false;
    var blnCryoPlacard = false;
    var intStorageAreaItem6Qty = 0;

    /* ITEM 1 */
    if(aPremiseTotal[eATAClass21] > aSchedulePlacardLimit[eItem1_Class21]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass22Sub51] > aSchedulePlacardLimit[eItem1_Class22Sub51]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass22SubNot51] > aSchedulePlacardLimit[eItem1_Class22Other]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass23] > aSchedulePlacardLimit[eItem1_Class23]) blnHazchemRequired = true;
    // check total aeros > limit
    if(aPremiseTotal[eATAClassA21]+aPremiseTotal[eATAClassA22]+aPremiseTotal[eATAClassA2251]+aPremiseTotal[eATAClassA23] > aSchedulePlacardLimit[eItem1_Class2A]) {
        if(aPremiseTotal[eATAClassA21]>aSchedulePlacardLimit[eItem1_Class2A]) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        else if(aPremiseTotal[eATAClassA21]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        if(aPremiseTotal[eATAClassA22]>aSchedulePlacardLimit[eItem1_Class2A]) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        else if(aPremiseTotal[eATAClassA22]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        if(aPremiseTotal[eATAClassA2251]>aSchedulePlacardLimit[eItem1_Class2A]) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        else if(aPremiseTotal[eATAClassA2251]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        if(aPremiseTotal[eATAClassA23]>aSchedulePlacardLimit[eItem1_Class2A]) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        else if(aPremiseTotal[eATAClassA23]>(aSchedulePlacardLimit[eItem1_Class2A]*0.5) && intAeroCount>1) {
            blnHazchemRequired = true;
            blnAeroPlacard=true;
        }
        if(intAeroCount>1 && !blnAeroPlacard) { // add mixed class placard
            blnHazchemRequired = true;
        }
    }
    // check total cryos > limit
    intCryoTotal = aPremiseTotal[eATAClassC21] + aPremiseTotal[eATAClassC22] + aPremiseTotal[eATAClassC2251] + aPremiseTotal[eATAClassC23];
    if((intCryoTotal > aSchedulePlacardLimit[eItem1_Class2C]) && (aPremiseTotal[eATAClassC21]>aSchedulePlacardLimit[eItem1_Class2C])) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal > aSchedulePlacardLimit[eItem4a]) && (aPremiseTotal[eATAClassC21] > (aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    if((intCryoTotal > aSchedulePlacardLimit[eItem1_Class2C]) && (aPremiseTotal[eATAClassC22] > aSchedulePlacardLimit[eItem1_Class2C])) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aPremiseTotal[eATAClassC22]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    if((intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C]) && (aPremiseTotal[eATAClassC2251]>aSchedulePlacardLimit[eItem1_Class2C])) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aPremiseTotal[eATAClassC2251]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    if((intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C]) && (aPremiseTotal[eATAClassC23]>aSchedulePlacardLimit[eItem1_Class2C])) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    else if((intCryoCount>1) && (intCryoTotal>aSchedulePlacardLimit[eItem4a]) && (aPremiseTotal[eATAClassC23]>(aSchedulePlacardLimit[eItem1_Class2C]*0.5))) {
        blnHazchemRequired = true;
        blnCryoPlacard=true;
    }
    if(intCryoCount>1 && !blnCryoPlacard && intCryoTotal>aSchedulePlacardLimit[eItem1_Class2C] && intCryoTotal<aSchedulePlacardLimit[eItem4a]) {
        // add mixed class placard
        blnHazchemRequired = true;
    }
    /* END ITEM 1 */
    /* ITEM 2 */
    // 3
    if(aPremiseTotal[eATAClass3Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass3Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass3Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if(((aPremiseTotal[eATAClass3Pack1]+aPremiseTotal[eATAClass3Pack2]+aPremiseTotal[eATAClass3Pack3]) > aSchedulePlacardLimit[eItem2_PackM])) blnHazchemRequired = true;
    // 4
    if(aPremiseTotal[eATAClass41Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass41Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass41Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass41Pack1]+aPremiseTotal[eATAClass41Pack2]+aPremiseTotal[eATAClass41Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass42Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass42Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass42Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass42Pack1]+aPremiseTotal[eATAClass42Pack2]+aPremiseTotal[eATAClass42Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass43Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass43Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass43Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass43Pack1]+aPremiseTotal[eATAClass43Pack2]+aPremiseTotal[eATAClass43Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    // 5
    if(aPremiseTotal[eATAClass51Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass51Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass51Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass51Pack1]+aPremiseTotal[eATAClass51Pack2]+aPremiseTotal[eATAClass51Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass52Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass52Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass52Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass52Pack1]+aPremiseTotal[eATAClass52Pack2]+aPremiseTotal[eATAClass52Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    // 6
    if(aPremiseTotal[eATAClass61Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass61Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass61Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass61Pack1]+aPremiseTotal[eATAClass61Pack2]+aPremiseTotal[eATAClass61Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    // 8
    if(aPremiseTotal[eATAClass8Pack1] > aSchedulePlacardLimit[eItem2_Pack1]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass8Pack2] > aSchedulePlacardLimit[eItem2_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass8Pack3] > aSchedulePlacardLimit[eItem2_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass8Pack1]+aPremiseTotal[eATAClass8Pack2]+aPremiseTotal[eATAClass8Pack3]) > aSchedulePlacardLimit[eItem2_PackM]) blnHazchemRequired = true;
    /* END ITEM 2 */
    /* ITEM 3 */
    // 9
    if(aPremiseTotal[eATAClass9Pack2] > aSchedulePlacardLimit[eItem3_Pack2]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAClass9Pack3] > aSchedulePlacardLimit[eItem3_Pack3]) blnHazchemRequired = true;
    if((aPremiseTotal[eATAClass9Pack2]+aPremiseTotal[eATAClass9Pack3]) > aSchedulePlacardLimit[eItem3_PackM]) blnHazchemRequired = true;
    /* ITEM 3 */
    /* ITEM 4 */
    if(aPremiseTotal[eATAMixed2000] > aSchedulePlacardLimit[eItem4a]) blnHazchemRequired = true;
    if(aPremiseTotal[eATAMixed5000] > aSchedulePlacardLimit[eItem4b]) blnHazchemRequired = true;
    /* END ITEM 4 */
    /* Item 6 */
    // GTDTT
    if(aPremiseTotal[eATAGTDTT] > aSchedulePlacardLimit[eItem5]) blnHazchemRequired = true;
    /* END Item 6 */
    /* special Regulation for subrisk 1 */
    if(aPremiseTotal[eATAClass1] >= 1 || aPremiseTotal[eATASubrisk1] >= 1) blnHazchemRequired = true;
    /* end special Regulation */

    /* SPECIAL LOGIC FOR Item 5 */
    /* CJH 01/04/2005 1.4.2 */

    /* These items are determined on a */
    /* per-storage area basis */

    /* Item 5 */
    // C1s, C2s and any FireRisks

    /*
    for each storage area
    	for each good
    		if good is in storage area
    			check for fire risk, c1, c2 and isolated
    			add total to Item 5 quantity
    		end if
    	next good
    next storage area
    */

	// each premise
    for(iPremise = 0; iPremise < numPremises; iPremise++) {
		blnHasC = false;
		blnHasFireRisk = false;
		intStorageAreaItem6Qty = 0;
		// each good
		for(iGood = 0; iGood < aGrandTotal.length; iGood++) {
			// check good is located in this premise
			if(aGrandTotal[iGood][eGTAStorageArea] == iPremise) {
				switch(aGrandTotal[iGood][eGTAClass]) {
					case C1:
						// C1 Isolated still apply for Item 5
						blnHasC = true;
						intStorageAreaItem6Qty += aGrandTotal[iGood][eGTAQuantity];
						break;
					case C2:
						blnHasC = true;
						intStorageAreaItem6Qty += aGrandTotal[iGood][eGTAQuantity];
						break;
					default:
						if(aGrandTotal[iGood][eGTAIsFireRisk] == true) {
							intStorageAreaItem6Qty += aGrandTotal[iGood][eGTAQuantity];
							blnHasFireRisk = true;
						}
				}
			}
		}
		if(blnHasC && blnHasFireRisk && (intStorageAreaItem6Qty > 0))
			intItem6Qty += intStorageAreaItem6Qty;
		if(intItem6Qty > aSchedulePlacardLimit[eItem5]) {
			blnHazchemRequired = true;
			break;
		}
    }

	/*
    if(aGrandTotal.length>0) {
        for(intAA=0; intAA<numGoods; intAA++) {
			if(aGrandTotal[intAA][eGTAClass]==C1) {
				intItem6Qty+=aGrandTotal[intAA][eGTAQuantity];
				blnHasC = true;
			}
			else if(aGrandTotal[intAA][eGTAClass]==C2) {
				intItem6Qty+=aGrandTotal[intAA][eGTAQuantity];
				blnHasC = true;
				blnC1Isolated = false;
			}
			else {
				blnC1Isolated = false;
				if(aGrandTotal[intAA][eGTAIsFireRisk]==true) {
					intItem6Qty+=aGrandTotal[intAA][eGTAQuantity];
				}
			}
        }
    }
    if((intItem6Qty > aSchedulePlacardLimit[eItem5]) && (aPremiseTotal[eATAHasFireRisk]>0) && blnHasC) blnHazchemRequired = true;
    */

    /* END Item 5 */

    /* END SPECIAL LOGIC FOR Item 5 */

    /* ITEM 7 */
    /* Modified to catch all C1 regardless */
    /* CJH 01/04/2005 1.4.2 */
    // Exempt goods DO contribute to placarding for the area because
    // the exemption is only for the bulk placard actually on the bulk
    // goods.
    // C1
	if((aPremiseTotal[eATAC1Bulk]+aPremiseTotal[eATAC1BulkNotIsolated]) > aSchedulePlacardLimit[eItem7_Bulk]) blnHazchemRequired = true;
	else if((aPremiseTotal[eATAC1Packaged]+aPremiseTotal[eATAC1PackagedNotIsolated]) > aSchedulePlacardLimit[eItem7_Pack]) blnHazchemRequired = true;
	else if((aPremiseTotal[eATAC1Bulk]+aPremiseTotal[eATAC1BulkNotIsolated]+aPremiseTotal[eATAC1Packaged]+aPremiseTotal[eATAC1PackagedNotIsolated]) > aSchedulePlacardLimit[eItem7_BulkPack]) blnHazchemRequired = true;

    /* END ITEM 7 */

}

/* Function: checkAllPremises()                            */
/* This function checks all premises for placarding        */
/* requirements and also for Regulations 39.2.b and 39.2.c     */
/* Then it checks all areas for manifesting before         */
/* checking the entire premises for hazchem.               */
/* INPUTS : none                                           */
/* OUTPUTS: none                                           */
function checkAllPremises() {
    for(idxPremise=0; idxPremise<numPremises; idxPremise++)     {
        checkAreaPlacarding(idxPremise)
        var intDGCount = checkForOtherDGs(idxPremise);
        /* Regulation 39(2)b */
        if (aAreaTotal[idxPremise][eATAClassCount] > 1) {
            // Item 1
            if ((aAreaTotal[idxPremise][eATASubrisk21]>0) &&
                    (aAreaTotal[idxPremise][eATAClass21]>0) &&
                    (aAreaTotal[idxPremise][eATAClass21] +
                    aAreaTotal[idxPremise][eATASubrisk21] >
                    placard_Regulation_39_2_b)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass21, strReason392b)
            }
            // ASSUMPTION: determining Regulation 39(2)b for Class 2.2 Subrisk 5.1
            // Add sub 2.2s to 2.2 Sub 5.1s and 2.2 Others
            // 2.2s and 2.2 Sub5.1s calcualted separately
            if ((aAreaTotal[idxPremise][eATASubrisk22] > 0) &&
                    (aAreaTotal[idxPremise][eATAClass22Sub51] > 0) &&
                    (aAreaTotal[idxPremise][eATAClass22Sub51] +
                    aAreaTotal[idxPremise][eATASubrisk22] >
                    placard_Regulation_39_2_b)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass22Sub51, strReason392b);
            }
            if ((aAreaTotal[idxPremise][eATASubrisk22] > 0) &&
                    (aAreaTotal[idxPremise][eATAClass22SubNot51] +
                    aAreaTotal[idxPremise][eATASubrisk22] >
                    placard_Regulation_39_2_b)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass22, strReason392b);
            }
            // END ASSUMPTION
            if((aAreaTotal[idxPremise][eATASubrisk23]>0) && (aAreaTotal[idxPremise][eATAClass23]>0)
               && (aAreaTotal[idxPremise][eATAClass23]+aAreaTotal[idxPremise][eATASubrisk23] > placard_Regulation_39_2_b)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass23, strReason392b)
            }
            // Item 2
            // check if any of the packing groups have quantities, then add them up including subrisk and see if larger than 39(2)b quantity
            // As per instructions from Ed Oberg 11:00 21 May 2003
            if ((aAreaTotal[idxPremise][eATASubrisk3]>0) && ((aAreaTotal[idxPremise][eATAClass3Pack1]>0)||(aAreaTotal[idxPremise][eATAClass3Pack2]>0)||(aAreaTotal[idxPremise][eATAClass3Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass3Pack1]+aAreaTotal[idxPremise][eATAClass3Pack2]+aAreaTotal[idxPremise][eATAClass3Pack3]+aAreaTotal[idxPremise][eATASubrisk3] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass3, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk41]>0) && ((aAreaTotal[idxPremise][eATAClass41Pack1]>0)||(aAreaTotal[idxPremise][eATAClass41Pack2]>0)||(aAreaTotal[idxPremise][eATAClass41Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass41Pack1]+aAreaTotal[idxPremise][eATAClass41Pack2]+aAreaTotal[idxPremise][eATAClass41Pack3]+aAreaTotal[idxPremise][eATASubrisk41] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass41, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk42]>0) && ((aAreaTotal[idxPremise][eATAClass42Pack1]>0)||(aAreaTotal[idxPremise][eATAClass42Pack2]>0)||(aAreaTotal[idxPremise][eATAClass42Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass42Pack1]+aAreaTotal[idxPremise][eATAClass42Pack2]+aAreaTotal[idxPremise][eATAClass42Pack3]+aAreaTotal[idxPremise][eATASubrisk42] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass42, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk43]>0) && ((aAreaTotal[idxPremise][eATAClass43Pack1]>0)||(aAreaTotal[idxPremise][eATAClass43Pack2]>0)||(aAreaTotal[idxPremise][eATAClass43Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass43Pack1]+aAreaTotal[idxPremise][eATAClass43Pack2]+aAreaTotal[idxPremise][eATAClass43Pack3]+aAreaTotal[idxPremise][eATASubrisk43] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass43, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk51]>0) && ((aAreaTotal[idxPremise][eATAClass51Pack1]>0)||(aAreaTotal[idxPremise][eATAClass51Pack2]>0)||(aAreaTotal[idxPremise][eATAClass51Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass51Pack1]+aAreaTotal[idxPremise][eATAClass51Pack2]+aAreaTotal[idxPremise][eATAClass51Pack3]+aAreaTotal[idxPremise][eATASubrisk51]+aAreaTotal[idxPremise][eATASubrisk52] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass51, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk52]>0) && ((aAreaTotal[idxPremise][eATAClass52Pack1]>0)||(aAreaTotal[idxPremise][eATAClass52Pack2]>0)||(aAreaTotal[idxPremise][eATAClass52Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass52Pack1]+aAreaTotal[idxPremise][eATAClass52Pack2]+aAreaTotal[idxPremise][eATAClass52Pack3]+aAreaTotal[idxPremise][eATASubrisk52] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass52, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk61]>0) && ((aAreaTotal[idxPremise][eATAClass61Pack1]>0)||(aAreaTotal[idxPremise][eATAClass61Pack2]>0)||(aAreaTotal[idxPremise][eATAClass61Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass61Pack1]+aAreaTotal[idxPremise][eATAClass61Pack2]+aAreaTotal[idxPremise][eATAClass61Pack3]+aAreaTotal[idxPremise][eATASubrisk61] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass61, strReason392b)
            if ((aAreaTotal[idxPremise][eATASubrisk8]>0) && ((aAreaTotal[idxPremise][eATAClass8Pack1]>0)||(aAreaTotal[idxPremise][eATAClass8Pack2]>0)||(aAreaTotal[idxPremise][eATAClass8Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass8Pack1]+aAreaTotal[idxPremise][eATAClass8Pack2]+aAreaTotal[idxPremise][eATAClass8Pack3]+aAreaTotal[idxPremise][eATASubrisk8] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass8, strReason392b)
            // Item 3
            if((aAreaTotal[idxPremise][eATASubrisk9]>0) && ((aAreaTotal[idxPremise][eATAClass9Pack2]>0)||(aAreaTotal[idxPremise][eATAClass8Pack3]>0)) && (aAreaTotal[idxPremise][eATAClass9Pack2]+aAreaTotal[idxPremise][eATAClass9Pack3]+aAreaTotal[idxPremise][eATASubrisk9] > placard_Regulation_39_2_b)) addToAreaPlacardArray(idxPremise, true, eAPRClass9, strReason392b)
        }
        /* END Regulation 39(2)b */
        /* Regulation 39(2)c */        
        
        if(aAreaPlacard[idxPremise][eAPRMixedClass]) {            
            /* ITEM 1 */
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass21, eItem1_Class21)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass21, strReason392c);
            }
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass22Sub51, eItem1_Class22Sub51)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass22Sub51, strReason392c);
            }
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass22SubNot51, eItem1_Class22Other)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass22, strReason392c);
            }
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass23, eItem1_Class23)) {
                addToAreaPlacardArray(idxPremise, true, eAPRClass23, strReason392c);
            }
            /* 24 oct 2003 new aero/cryo rules */
            // if dgs mixed with aeros or cryos then treat as virtual classes for 39(2)c
            if(intDGCount>0) {
                // check for aero cryo special rules
                var blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass21] > 0) || (aAreaTotal[idxPremise][eATAClass22Sub51] > 0) || (aAreaTotal[idxPremise][eATAClass22SubNot51] > 0) || (aAreaTotal[idxPremise][eATAClass23] > 0))
                    blnClass2Only = true;
                if((aAreaTotal[idxPremise][eATAClass3Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass3Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass3Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass41Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass41Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass41Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass42Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass42Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass42Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass43Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass43Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass43Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass51Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass51Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass51Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass52Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass52Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass52Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass61Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass61Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass61Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass8Pack1] > 0) || (aAreaTotal[idxPremise][eATAClass8Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass8Pack3] > 0))
                    blnClass2Only = false;
                if((aAreaTotal[idxPremise][eATAClass9Pack2] > 0) || (aAreaTotal[idxPremise][eATAClass9Pack3] > 0))
                    blnClass2Only = false;

                if(blnClass2Only) {
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassA21, eItem1_Class2A))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule3 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassA22, eItem1_Class2A))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule3 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassA23, eItem1_Class2A))
	                addToAreaPlacardArray(idxPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule3 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassC21, eItem1_Class2C))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule3 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassC22, eItem1_Class2C))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule3 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassC23, eItem1_Class2C))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule3 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Class 2 Dangerous Goods)")
                }
                else {
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassA21, eItem1_Class2A))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule4 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassA22, eItem1_Class2A))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule4 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassA23, eItem1_Class2A))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule4 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassC21, eItem1_Class2C))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass21, strReasonAeroCryo);//strReasonRule4 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassC22, eItem1_Class2C))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass22, strReasonAeroCryo);//strReasonRule4 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                    if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClassC23, eItem1_Class2C))
                        addToAreaPlacardArray(idxPremise, true, eAPRClass23, strReasonAeroCryo);//strReasonRule4 + " (50% Aerosols/Cryogenic Fluids stored and handled with other Dangerous Goods)")
                }

            }
            /* end 24 oct 2003 rules */
            /* END ITEM 1 */
            /* ITEM 2 */
            // 3
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass3Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass3, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass3Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass3, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass3Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass3, strReason392c)
            else if(((aAreaTotal[idxPremise][eATAClass3Pack1]+aAreaTotal[idxPremise][eATAClass3Pack2]+aAreaTotal[idxPremise][eATAClass3Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) && !aAreaPlacard[idxPremise][eAPRClass3]) addToAreaPlacardArray(idxPremise, true, eAPRClass3, strReason392c)
            // 4
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass41Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass41, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass41Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass41, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass41Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass41, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass41Pack1]+aAreaTotal[idxPremise][eATAClass41Pack2]+aAreaTotal[idxPremise][eATAClass41Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass41, strReason392c)
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass42Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass42, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass42Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass42, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass42Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass42, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass42Pack1]+aAreaTotal[idxPremise][eATAClass42Pack2]+aAreaTotal[idxPremise][eATAClass42Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass42, strReason392c)
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass43Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass43, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass43Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass43, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass43Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass43, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass43Pack1]+aAreaTotal[idxPremise][eATAClass43Pack2]+aAreaTotal[idxPremise][eATAClass43Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass43, strReason392c)
            // 5
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass51Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass51, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass51Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass51, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass51Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass51, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass51Pack1]+aAreaTotal[idxPremise][eATAClass51Pack2]+aAreaTotal[idxPremise][eATAClass51Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass51, strReason392c)
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass52Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass52, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass52Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass52, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass52Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass52, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass52Pack1]+aAreaTotal[idxPremise][eATAClass52Pack2]+aAreaTotal[idxPremise][eATAClass52Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass52, strReason392c)
            // 6
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass61Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass61, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass61Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass61, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass61Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass61, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass61Pack1]+aAreaTotal[idxPremise][eATAClass61Pack2]+aAreaTotal[idxPremise][eATAClass61Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass61, strReason392c)
            // 8
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass8Pack1, eItem2_Pack1)) addToAreaPlacardArray(idxPremise, true, eAPRClass8, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass8Pack2, eItem2_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass8, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass8Pack3, eItem2_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass8, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass8Pack1]+aAreaTotal[idxPremise][eATAClass8Pack2]+aAreaTotal[idxPremise][eATAClass8Pack3]) > (aSchedulePlacardLimit[eItem2_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass8, strReason392c)
            /* END ITEM 2 */
            /* ITEM 3 */
            // 9
            if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass9Pack2, eItem3_Pack2)) addToAreaPlacardArray(idxPremise, true, eAPRClass9, strReason392c)
            else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAClass9Pack3, eItem3_Pack3)) addToAreaPlacardArray(idxPremise, true, eAPRClass9, strReason392c)
            else if((aAreaTotal[idxPremise][eATAClass9Pack2]+aAreaTotal[idxPremise][eATAClass9Pack3]) > (aSchedulePlacardLimit[eItem3_PackM]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRClass9, strReason392c)
            /* ITEM 3 */

            /**************************************/
            /* Only items 1-3 apply to 39.2.c     */
            /**************************************/
            /* Item 6 */
            // GTDTT
            //if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAGTDTT, eItem5)) addToAreaPlacardArray(idxPremise, true, eAPRGTDTT, strReason392c)
            /* END Item 6 */
            /* Item 5 */
            // C1 and C2 with FireRisk
            //if((aAreaTotal[idxPremise][eATAC1Bulk]+aAreaTotal[idxPremise][eATAC1Packaged]+aAreaTotal[idxPremise][eATAC2Bulk]+aAreaTotal[idxPremise][eATAC2Packaged] ) > ( aSchedulePlacardLimit[eItem5]*0.5) && aAreaTotal[idxPremise][eATAHasFireRisk]) addToAreaPlacardArray(idxPremise, true, eAPRClass3, strReason392c)
            /* END Item 5 */
            /* ITEM 7 */
            // C1
            //if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAC1Bulk] + aAreaTotal[idxPremise][eATAC1BulkNotIsolated, eItem7_Bulk)) addToAreaPlacardArray(idxPremise, true, eAPRCombustibleLiquids, strReason392c)
            //else if(isAreaTotalOverHalfPlacardLimit(idxPremise, eATAC1Packaged] + aAreaTotal[idxPremise][eATAC1BulkNotIsolated, eItem7_Pack)) addToAreaPlacardArray(idxPremise, true, eAPRCombustibleLiquids, strReason392c)
            //else if((aAreaTotal[idxPremise][eATAC1Bulk]+aAreaTotal[idxPremise][eATAC1Packaged] + aAreaTotal[idxPremise][eATAC1BulkNotIsolated]+aAreaTotal[idxPremise][eATAC1PackagedNotIsolated]) > (aSchedulePlacardLimit[eItem7_BulkPack]*0.5)) addToAreaPlacardArray(idxPremise, true, eAPRCombustibleLiquids, strReason392c)
            /* END ITEM 7 */
        } else {
            overrideMixedClassLock = true;
        }
        /* END Regulation 39(2)c */        
        
        //alert('checking manifesting');
        checkAreaManifesting(idxPremise);        
        checkAreaFireProtectioning(idxPremise);
    }
    checkPremisesHazchem();
}
  
/*
requirement 3.6 for VWA modifications
return false if statements for class labels triggered, true if displaying just the mixed class label
*/ 
function isAreaTotalOverHalfPlacardLimit(idxPremise, classInt, classLimit) {
    var className = convertATAtoClass(classInt);
    var limit = aSchedulePlacardLimit[classLimit]*0.5;    
    var areaTotalForClass = aAreaTotal[idxPremise][classInt];
    var overLimit = areaTotalForClass > limit;
    var totalExceedsMixedLimit = quantityGrandTotal > aSchedulePlacardLimit[eItem4b];
    if (overLimit && totalExceedsMixedLimit && !displayMixedClassPlacard) {
        /* alert('over half limit (' + limit + ') so disabling the mixed class placard for '
              + className + '), quantityGrandTotal (' + quantityGrandTotal + ') > ' + aSchedulePlacardLimit[eItem4b]); */
        displayMixedClassPlacard = false;
    }
    return overLimit;
}

/* 
input: int - item
output: int - combined quantity for all classes inder this Item
*/
function getTotalQuantityForItem(item) {
	alert('getTotalQuantityForItem is currently unimplemented');	
}

/* 
input: int - item ; int premise identifier
output: int - combined quantity for all classes inder this Class
*/
function getTotalQuantityForClass(clazz, intPremise) {
    var totalQuantity = 0;   	    
    for(i=0; i<aGrandTotal.length; i++) {
        if (aGrandTotal[i][eGTAClass] == clazz) {
            totalQuantity += aGrandTotal[i][eGTAQuantity];
        }
    }
    return totalQuantity;
}