// Detect It Easy: DiE-JS framework file
// Don't change anything unless you're sure about what you're doing

var File = ELF;
var X = ELF;


var ELF_getSize = ELF.getSize,
    ELF_fileSize = ELF_getSize();

/**
 * Get the cached file size.
 * @returns {Number}
 */
ELF.getSize = function () {
    return ELF_fileSize;
}


var ELF_getNumberOfSections = ELF.getNumberOfSections,
    ELF_getSectionNumber = ELF.getSectionNumber,
    ELF_getSectionFileSize = ELF.getSectionFileSize,
    ELF_getSectionFileOffset = ELF.getSectionFileOffset,
    ELF_isSectionNamePresent = ELF.isSectionNamePresent,
    ELF_numberOfSections = ELF_getNumberOfSections(),
    ELF_sectionNumbers = {},
    ELF_sectionFileSizes = [],
    ELF_sectionFileOffsets = [],
    ELF_sectionNameSearchResults = {};

/**
 * Get the cached number of sections.
 * @returns {Number}
 */
ELF.getNumberOfSections = function () {
    return ELF_numberOfSections;
}


/**
 * Get a section number and cache the result.
 * @returns {Number}
 */
ELF.getSectionNumber = function (sSectionName) {
    var sCacheKey = "$" + sSectionName;

    if (ELF_sectionNumbers[sCacheKey] === undefined) {
        ELF_sectionNumbers[sCacheKey] = ELF_getSectionNumber(sSectionName);
    }

    return ELF_sectionNumbers[sCacheKey];
}


/**
 * Get a section file size from the cache.
 * @returns {Number}
 */
ELF.getSectionFileSize = function (nNumber) {
    if (nNumber < 0 || nNumber >= ELF_numberOfSections) {
        return ELF_getSectionFileSize(nNumber);
    }

    if (ELF_sectionFileSizes[nNumber] === undefined) {
        ELF_sectionFileSizes[nNumber] = ELF_getSectionFileSize(nNumber);
    }

    return ELF_sectionFileSizes[nNumber];
}


/**
 * Get a section file offset from the cache.
 * @returns {Number}
 */
ELF.getSectionFileOffset = function (nNumber) {
    if (nNumber < 0 || nNumber >= ELF_numberOfSections) {
        return ELF_getSectionFileOffset(nNumber);
    }

    if (ELF_sectionFileOffsets[nNumber] === undefined) {
        ELF_sectionFileOffsets[nNumber] = ELF_getSectionFileOffset(nNumber);
    }

    return ELF_sectionFileOffsets[nNumber];
}


/**
 * Check if a section name is present and cache the result.
 * @returns {Boolean}
 */
ELF.isSectionNamePresent = function (sSectionName) {
    var sCacheKey = "$" + sSectionName;

    if (ELF_sectionNameSearchResults[sCacheKey] === undefined) {
        ELF_sectionNameSearchResults[sCacheKey] = ELF_isSectionNamePresent(sSectionName);
    }

    return ELF_sectionNameSearchResults[sCacheKey];
}


var ELF_getNumberOfPrograms = ELF.getNumberOfPrograms,
    ELF_getProgramFileOffset = ELF.getProgramFileOffset,
    ELF_getProgramFileSize = ELF.getProgramFileSize,
    ELF_numberOfPrograms = ELF_getNumberOfPrograms(),
    ELF_programFileOffsets = [],
    ELF_programFileSizes = [];

/**
 * Get the cached number of programs.
 * @returns {Number}
 */
ELF.getNumberOfPrograms = function () {
    return ELF_numberOfPrograms;
}


/**
 * Get a program file offset from the cache.
 * @returns {Number}
 */
ELF.getProgramFileOffset = function (nNumber) {
    if (nNumber < 0 || nNumber >= ELF_numberOfPrograms) {
        return ELF_getProgramFileOffset(nNumber);
    }

    if (ELF_programFileOffsets[nNumber] === undefined) {
        ELF_programFileOffsets[nNumber] = ELF_getProgramFileOffset(nNumber);
    }

    return ELF_programFileOffsets[nNumber];
}


/**
 * Get a program file size from the cache.
 * @returns {Number}
 */
ELF.getProgramFileSize = function (nNumber) {
    if (nNumber < 0 || nNumber >= ELF_numberOfPrograms) {
        return ELF_getProgramFileSize(nNumber);
    }

    if (ELF_programFileSizes[nNumber] === undefined) {
        ELF_programFileSizes[nNumber] = ELF_getProgramFileSize(nNumber);
    }

    return ELF_programFileSizes[nNumber];
}


var ELF_isLibraryPresent = ELF.isLibraryPresent,
    ELF_librarySearchResults = {};

/**
 * Check if an imported library is present and cache the result.
 * @returns {Boolean}
 */
ELF.isLibraryPresent = function (sLibraryName) {
    var sCacheKey = "$" + sLibraryName;

    if (ELF_librarySearchResults[sCacheKey] === undefined) {
        ELF_librarySearchResults[sCacheKey] = ELF_isLibraryPresent(sLibraryName);
    }

    return ELF_librarySearchResults[sCacheKey];
}