using System;
using System.Collections.Generic;
using System.Linq;
public class PE_Formato
{
 
    public static string[] IMAGE_DOS_HEADER_64(string[] DosHeader)
 
    { // 64 bytes
 
        string[] Retorno = new string[19];
 
        Retorno[0] = "e_magic, Firma MZ" + ";" + TotalConversor.HextoStringASCII(DosHeader[0] + DosHeader[1]);
 
        Retorno[1] = "e_cblp, Bytes Codigo Ultima Pagina" + ";" + TotalConversor.ConVertBaseDecimal( DosHeader[3] + DosHeader[2],16); ;
 
        Retorno[2] = "e_cp, paginas en archivo" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[5] + DosHeader[4], 16); ;
 
        Retorno[3] = "e_crlc, reubicación" + ";" + DosHeader[7] + DosHeader[6];
 
        Retorno[4] = "e_cparhdr, Tamaño del encabezado en  párrafos" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[9] + DosHeader[8], 16);  // paragraphs (16 byte chunks)
 
        Retorno[5] = "e_minalloc, Mínimos párrafos adicionales necesarios" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[11] + DosHeader[10], 16);
 
        Retorno[6] = "e_maxalloc, Máximo de párrafos adicionales necesarios" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[13] + DosHeader[12], 16);
 
        Retorno[7] = "e_ss, Valor inicial (relativo) SS" + ";" + DosHeader[15] + DosHeader[14];
 
        Retorno[8] = "e_sp, Valor inicial del SP" + ";" + DosHeader[17] + DosHeader[16];
 
        Retorno[9] = "e_csum, Checksum" + ";" + DosHeader[18] + DosHeader[19];  //++
 
        Retorno[10] = "e_ip, Valor IP inicial" + ";" + DosHeader[21] + DosHeader[20];
 
        Retorno[11] = "e_cs, Valor inicial (relativo) CS" + ";" + DosHeader[23] + DosHeader[22];
 
        Retorno[12] = "e_lfarlc, Dirección de archivo de la tabla de reubicación INICIO STUB??" + ";" + DosHeader[25] + DosHeader[24];
 
        Retorno[13] = "e_ovno, Número de superposición" + ";" + DosHeader[27] + DosHeader[26];
 
        Retorno[14] = "e_res[4]" + ";" + DosHeader[29] + DosHeader[28]; //  34-35
 
        Retorno[15] = "e_oemid, OEM identificador (para e_oeminfo)" + ";" + DosHeader[37] + DosHeader[36];
 
        Retorno[16] = "e_oeminfo,  OEM información específico e_oemid " + ";" + DosHeader[39] + DosHeader[38];
 
        Retorno[17] = "e_res2[10]" + ";" + DosHeader[41] + DosHeader[40];  // 58-59
 
        Retorno[18] = "Puntero Encabezado PE RVA" + ";" + DosHeader[63] + DosHeader[62] + DosHeader[61] + DosHeader[60];
 
 
        return Retorno;
    }
 
    public static string[] IMAGE_FILE_HEADER_24(string[] FileHeader)
    { //
 
        string[] Retorno = new string[8];
 
        Retorno[0] = "Signature, firma del archivo en este caso PE00 PE� 90 0" + ";" + TotalConversor.HextoStringASCII(FileHeader[0] + FileHeader[1] + FileHeader[2] + FileHeader[3]);
 
        Retorno[1] = "Machine, Procesador Arquitectura 014C–X86-32 8664-X86-64  0000–todos 0200-IA64" + ";" + FileHeader[5] + FileHeader[4]; //++
 
        Retorno[2] = "NumberOfSections, Número de secciones" + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[7] + FileHeader[6], 16); 
 
        Retorno[3] = "TimeDateStamp, Los 32 bits bajos del número de segundos desde las 00:00 del 1 de enero de 1970" + ";" + TotalConversor.ConvertExaFechaEsamblado(FileHeader[11] + FileHeader[10] + FileHeader[9] + FileHeader[8]); //++
 
        Retorno[4] = "PointerToSymbolTable, Pointer A la tabla de símbolos  OBSOLETO IMG 00000000 RVA" + ";" + FileHeader[15] + FileHeader[14] + FileHeader[13] + FileHeader[12];
 
        Retorno[5] = "NumberOfSymbols, Número de símbolos OBSOLETO IMG 00000000" + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[19] + FileHeader[18]+ FileHeader[17] + FileHeader[16], 16); 
 
        Retorno[6] = "SizeOfOptionalHeader, Tamaño del encabezado opcional  Para archivo de imagen " + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[21] + FileHeader[20], 16);
 
        Retorno[7] = "Characteristics, Características  ****" + ";" + FileHeader[23] + FileHeader[22]; //++
 
 
       return Retorno;
    }  /* TOTAL 24 BYTES */
 
    public static string[] IMAGE_OPTIONAL_HEADER64_112(string[] OpHeader)
    {
        string[] Retorno = new string[29];
 
        Retorno[0] = "Magic, 010B -32  020B -64   0107 -ROM  0000 -dual" + ";" + OpHeader[1] + OpHeader[0];
 
        Retorno[1] = "MajorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[2],16);
 
        Retorno[2] = "MinorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[3],16);
 
        Retorno[3] = "SizeOfCode, tamaño del codigo maquina en todas las secciones" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[7] + OpHeader[6] + OpHeader[5] + OpHeader[4],16);
 
        Retorno[4] = "SizeOfInitializedData, tamaño de la sección de datos iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[11] + OpHeader[10] + OpHeader[9] + OpHeader[8],16);
 
        Retorno[5] = "SizeOfUninitializedData, tamaño de la sección de datos no iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[15] + OpHeader[14] + OpHeader[13] + OpHeader[12],16); 
 
        Retorno[6] = "AddressOfEntryPoint, dirección de la primera instrucion que se ejecuta en memoria RVA" + ";" + OpHeader[19] + OpHeader[18] + OpHeader[17] + OpHeader[16];
 
        Retorno[7] = "BaseOfCode,dirección relativa de la base del código RVA" + ";" + OpHeader[23] + OpHeader[22] + OpHeader[21] + OpHeader[20]; 
 
        Retorno[8] = "ImageBase,dirección base preferida RVAbp" + ";" + OpHeader[31] + OpHeader[30] + OpHeader[29] + OpHeader[28] + OpHeader[27] + OpHeader[26] + OpHeader[25] + OpHeader[24]; 
 
        Retorno[9] = "SectionAlignment, alineación de las secciones >= a FileAlignment Pagina32-4096bytes" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[35] + OpHeader[34] + OpHeader[33] + OpHeader[32],16);
 
        Retorno[10] = "FileAlignment,factor de alineación 512Bytes-64K potencias de 2" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[39] + OpHeader[38] + OpHeader[37] + OpHeader[36],16);
 
        Retorno[11] = "MajorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[41] + OpHeader[40],16);
 
        Retorno[12] = "MinorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[43] + OpHeader[42],16);
 
        Retorno[13] = "MajorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[45] + OpHeader[44],16);
 
        Retorno[14] = "MinorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[47] + OpHeader[46],16);
 
        Retorno[15] = "MajorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[49] + OpHeader[48],16);
 
        Retorno[16] = "MinorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[51] + OpHeader[50],16);
 
        Retorno[17] = "Win32VersionValue," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[52] + OpHeader[53] + OpHeader[54] + OpHeader[55],16);
 
        Retorno[18] = "SizeOfImage,un múltiplo de SectionAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[59] + OpHeader[58] + OpHeader[57] + OpHeader[56],16);
 
        Retorno[19] = "SizeOfHeaders,tamaño de todos los encabezados redondeado a un múltiplo de FileAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[63] + OpHeader[62] + OpHeader[61] + OpHeader[60],16);
 
        Retorno[20] = "CheckSum,algoritmo utilizado se toma de la librería IMAGEHELP.DLL" + ";" + OpHeader[67] + OpHeader[66] + OpHeader[65] + OpHeader[64]; //++
 
        Retorno[21] = "Subsystem, tipo de subsistema necesario" + ";" + OpHeader[69] + OpHeader[68];
 
        Retorno[22] = "DllCharacteristics, punto de entrada para las DLL" + ";" + OpHeader[71] + OpHeader[70];
 
        Retorno[23] = "SizeOfStackReserve, tamaño que se debe reservar en la pila" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[79] + OpHeader[78] + OpHeader[77] + OpHeader[76] + OpHeader[75] + OpHeader[74] + OpHeader[73] + OpHeader[72],16);
 
        Retorno[24] = "SizeOfStackCommit, Tamaño utilizado por la pila en men" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[87] + OpHeader[86] + OpHeader[85] + OpHeader[84] + OpHeader[83] + OpHeader[82] + OpHeader[81] + OpHeader[80],16);
 
        Retorno[25] = "SizeOfHeapReserve, tamaño reservado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[95] + OpHeader[94] + OpHeader[93] + OpHeader[92] + OpHeader[91] + OpHeader[90] + OpHeader[89] + OpHeader[88],16);
 
        Retorno[26] = "SizeOfHeapCommit, tamaño utilizado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[103] + OpHeader[102] + OpHeader[101] + OpHeader[100] + OpHeader[99] + OpHeader[98] + OpHeader[97] + OpHeader[96],16);
 
        Retorno[27] = "LoaderFlags, tamaño de los loaderFlags. Su valor es reservado y siempre es cero." + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[107] + OpHeader[106] + OpHeader[105] + OpHeader[104], 16);
 
        Retorno[28] = "NumberOfRvaAndSizes, Cantidad de DataDirectory" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[111] + OpHeader[110] + OpHeader[109] + OpHeader[108],16);
 
        return Retorno;
    }    /* TOTAL 112 BYTES */
 
    public static string[] IMAGE_OPTIONAL_HEADER32_96(string[] OpHeader)
    {
        string[] Retorno = new string[30];
 
        Retorno[0] = "Magic, 010B -32  020B -64   0107 -ROM  0000 -dual" + ";" + OpHeader[1] + OpHeader[0];
 
        Retorno[1] = "MajorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[2],16);
 
        Retorno[2] = "MinorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[3],16);
 
        Retorno[3] = "SizeOfCode, tamaño del codigo maquina en todas las secciones" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[7] + OpHeader[6] + OpHeader[5] + OpHeader[4], 16);
 
        Retorno[4] = "SizeOfInitializedData, tamaño de la sección de datos iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[11] + OpHeader[10] + OpHeader[9] + OpHeader[8], 16);
 
        Retorno[5] = "SizeOfUninitializedData, tamaño de la sección de datos no iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[15] + OpHeader[14] + OpHeader[13] + OpHeader[12], 16);
 
        Retorno[6] = "AddressOfEntryPoint, dirección de la primera instrucion que se ejecuta en memoria RVA" + ";" + OpHeader[19] + OpHeader[18] + OpHeader[17] + OpHeader[16];
 
        Retorno[7] = "BaseOfCode,dirección relativa de la base del código RVA" + ";" + OpHeader[23] + OpHeader[22] + OpHeader[21] + OpHeader[20];
 
        Retorno[8]= "campo+ Base de datos ,La dirección relativa a la base de la imagen de la sección de principio de datos cuando se carga en la memoria RVA" + ";" + OpHeader[27] + OpHeader[26] + OpHeader[25] + OpHeader[24];
 
        Retorno[9] = "ImageBase,dirección base preferida RVAbp" + ";"  + OpHeader[31] + OpHeader[30] + OpHeader[29] + OpHeader[28];
 
        Retorno[10] = "SectionAlignment, alineación de las secciones >= a FileAlignment Pagina32-4096bytes" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[35] + OpHeader[34] + OpHeader[33] + OpHeader[32], 16);
 
        Retorno[11] = "FileAlignment,factor de alineación 512Bytes-64K potencias de 2" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[39] + OpHeader[38] + OpHeader[37] + OpHeader[36], 16);
 
        Retorno[12] = "MajorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[41] + OpHeader[40],16);
 
        Retorno[13] = "MinorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[43] + OpHeader[42],16);
 
        Retorno[14] = "MajorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[45] + OpHeader[44],16);
 
        Retorno[15] = "MinorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[47] + OpHeader[46],16);
 
        Retorno[16] = "MajorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[49] + OpHeader[48],16);
 
        Retorno[17] = "MinorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[51] + OpHeader[50],16);
 
        Retorno[18] = "Win32VersionValue," + ";" + OpHeader[52] + OpHeader[53] + OpHeader[54] + OpHeader[55];
 
        Retorno[19] = "SizeOfImage,un múltiplo de SectionAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[59] + OpHeader[58] + OpHeader[57] + OpHeader[56], 16);
 
        Retorno[20] = "SizeOfHeaders,tamaño de todos los encabezados redondeado a un múltiplo de FileAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[63] + OpHeader[62] + OpHeader[61] + OpHeader[60], 16);
 
        Retorno[21] = "CheckSum,algoritmo utilizado se toma de la librería IMAGEHELP.DLL" + ";" + OpHeader[64] + OpHeader[65] + OpHeader[66] + OpHeader[67];
 
        Retorno[22] = "Subsystem, tipo de subsistema necesario" + ";" + OpHeader[68] + OpHeader[69];
 
        Retorno[23] = "DllCharacteristics, punto de entrada para las DLL" + ";" + OpHeader[71] + OpHeader[70];
 
        Retorno[24] = "SizeOfStackReserve, tamaño que se debe reservar en la pila" + ";" + TotalConversor.ConVertBaseDecimal( OpHeader[75] + OpHeader[74] + OpHeader[73] + OpHeader[72], 16);
 
        Retorno[25] = "SizeOfStackCommit, Tamaño utilizado por la pila en men" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[79] + OpHeader[78] + OpHeader[77] + OpHeader[76], 16);
 
        Retorno[26] = "SizeOfHeapReserve, tamaño reservado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[83] + OpHeader[82] + OpHeader[81] + OpHeader[80], 16);
 
        Retorno[27] = "SizeOfHeapCommit, tamaño utilizado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal( OpHeader[87] + OpHeader[86] + OpHeader[85] + OpHeader[84], 16);
 
        Retorno[28] = "LoaderFlags, tamaño de los loaderFlags. Su valor es reservado y siempre es cero." + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[91] + OpHeader[90] + OpHeader[89] + OpHeader[88], 16);
 
        Retorno[29] = "NumberOfRvaAndSizes, Cantidad de DataDirectory" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[95] + OpHeader[94] + OpHeader[93] + OpHeader[92], 16);
 
        return Retorno;
    }    /* TOTAL 96 BYTES */
 
    public static string[] IMAGE_SECTION_HEADER_40(string[] SeHeader)
    {
        string[] Retorno = new string[10];
 
        Retorno[0] = "Name[IMAGE_SIZEOF_SHORT_NAME], 8-byte ANSI name" + ";" + TotalConversor.HextoStringASCII( SeHeader[0] + SeHeader[1] + SeHeader[2] + SeHeader[3] + SeHeader[4] + SeHeader[5] + SeHeader[6] + SeHeader[7]);
 
        Retorno[1] = "Misc, PhysicalAddress dirección física o VirtualSize tamaño de la sección antes del redondeo" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[11] + SeHeader[10] + SeHeader[9] + SeHeader[8],16);
 
        Retorno[2] = "VirtualAddress, dirección del primer byte de la sección RVA" + ";" + SeHeader[15] + SeHeader[14] + SeHeader[13] + SeHeader[12];
 
        Retorno[3] = "SizeOfRawData, tamaño de los datos inicializados" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[19] + SeHeader[18] + SeHeader[17] + SeHeader[16],16);
 
        Retorno[4] = "PointerToRawData, puntero a la primera pagina RVA" + ";" + SeHeader[23] + SeHeader[22] + SeHeader[21] + SeHeader[20];
 
        Retorno[5] = "PointerToRelocations, puntero a la primera if reubicación RVA" + ";" + SeHeader[27] + SeHeader[26] + SeHeader[25] + SeHeader[24];
 
        Retorno[6] = "PointerToLinenumbers, puntero a la primer if numerado RVA" + ";" + SeHeader[31] + SeHeader[30] + SeHeader[29] + SeHeader[28];
 
        Retorno[7] = "NumberOfRelocations" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[33] + SeHeader[32],16);
 
        Retorno[8] = "NumberOfLinenumbers" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[35] + SeHeader[34],16);
 
        Retorno[9] = "Characteristics" + ";" + SeHeader[39] + SeHeader[38] + SeHeader[37] + SeHeader[36]; //++
 
        return Retorno;
    } // 40 bytes
 
 
    public static string[] IMAGE_DATA_DIRECTORY_8(string[] DiHeader)
    {
        string[] Retorno = new string[2];
 
        Retorno[0] = "VirtualAddress RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];
 
        Retorno[1] = "Size" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4], 16); //  TamañoDirectorio / bytes de la estructura del mismo = numero de estructuras  que apuntan a funciones de las dll(s)
 
        return Retorno;
 
    } // 8 bytes ojo hay 16 definidos total 128 bytes
 
    public static string[] IMAGE_EXPORT_DIRECTORY_40(string[] DiHeader) // The .edata Section (Image Only)  ojo   TamañoDirectorio / 40 = X estructuras, cada una apunta a una matriz de  funciones  de una dll, la ultima estructura es null
    { //  DataDirectory
 
        string[] Retorno = new string[11];
 
 
        Retorno[0] = "Characteristics, Export Flags Reserved, must be 0" + ";" + DiHeader[0] + DiHeader[1] + DiHeader[2] + DiHeader[3];
 
        Retorno[1] = "TimeDateStamp," + ";" + TotalConversor.ConvertExaFechaEsamblado(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
 
        Retorno[2] = "Major Version," + ";" + DiHeader[9] + DiHeader[8];
 
        Retorno[3] = "Minor Version," + ";" + DiHeader[11] + DiHeader[10];
 
        Retorno[4] = "Name, RVA La dirección de la cadena ASCII que contiene el nombre de la DLL RVA" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
 
        Retorno[5] = "Base, El número ordinal inicial DE LAS FUNCIONES" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16],16);
 
        Retorno[6] = "NumberOfFunctions, El número de funciones exportadas por nombre u ordinal" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20],16);
 
        Retorno[7] = "NumberOfName, número de nombres exportados" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24],16);
 
        Retorno[8] = "AddressOfFunctions, RVA apunta a una matriz de valores de 32 bits RVA" + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];
 
        Retorno[9] = "AddressOfName, RVA apunta a una matriz de valores de 32 bits RVA" + ";" + DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32];
 
        Retorno[10] = "AddressOfNameOrdinal, RVA apunta a una matriz de valores de 16 bits RVA" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];
 
        return Retorno;
 
    } // 40 Bytes The .edata Section (Image Only)
 
 
    public static string[] IMAGE_IMPORT_DESCRIPTOR_20(string[] DiHeader) // The .idata Section              ojo   TamañoDirectorio / 20 = X estructuras, cada una apunta a una matriz de  funciones  de una dll, la ultima estructura es null
    { //  DataDirectory
 
        string[] Retorno = new string[5];
 
 
        Retorno[0] = " ImportLookup, Table RVA *Original apunta a una matriz de nombres ú ordinal y termina en puntero nulo RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // apunta a 32 o 64 bits
 
        Retorno[1] = "TimeDateStamp, valor=  0 o F si es importacion " + ";" + TotalConversor.ConvertExaFechaEsamblado(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
 
        Retorno[2] = " ForwarderChain, El índice de la primera redirección de la cadena obsoleto" + ";" + DiHeader[11] + DiHeader[10]+ DiHeader[9] + DiHeader[8] ;
 
        Retorno[3] = " Name,  RVA-base ASCII string, nombre de la DLL importada, null-terminated  RVA" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
 
        Retorno[4] = "PIMAGE_THUNK_DATA ,Table RVA *Actual apunta a un matriz de punteros VA de las funciones importadas y termina en un puntero nulo dentro del PE OJO_VA" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16]; // apunta a 32 o 64 bits
        // una vez cargado apuntan a la misma estructura(original y actual)
        return Retorno;
 
    } // 20 Bytes The .idata Section (Image Only)
 
    public static string Import_String_ASCII(string[] DiHeader) // The .idata Section
    { //  DataDirectory
 
        string Retorno;
 
        Retorno = TotalConversor.HextoStringASCII(string.Concat (DiHeader));
 
        return Retorno;
 
    } // Nº ? Bytes import name
 
 
 
    public static string[] IMAGE_IMPORT_Lookup_8_4(string[] DiHeader) // The .idata Section
    { //  DataDirectory_Import  ordinal o nombre de la funcion importada de la DLL, Bits 63 to 32 are zero. se importa por nombre
 
        string[] Retorno = new string[3];
 
 
 
        if (DiHeader.Length > 4) { Retorno[0] = " OrdinalNameFlag,  Ordinal/Name Flag bit field " + ";" + DiHeader[7]; } else { Retorno[0] = " OrdinalNameFlag,  " + ";" + DiHeader[3]; }
 
 
        Retorno[1] = "OrdinalNumber, Ordinal Flag bit field is 1" + ";"  + TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16); // 63 to 16 must be 0.  or 31 to 16 must be 0, SOLO SI EL BIT MAS SIGNIFICATIVO ES 1.  nos da directamente el ordinal de la funcion importada. 
        // investigando la DLL obtenemos la función utilizada
        Retorno[2] = "HintName, Table RVA  Ordinal/Name Flag bit field is 0 RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // if 64 bits los Bits 63 to 32 are zero. se importa por nombre Ordinal/Name Flag bit field is 0 
 
 
        return Retorno;
 
    } // 8_4 Bytes The .idata. storted in r.data Section (Image Only)
 
 
    public static string[] IMAGE_RESOURCE_DIRECTORY_NODE_HEADER_16(string[] DiHeader) // The .rsrc Section   
    {
 
        string[] Retorno = new string[6];
 
        Retorno[0] = "DWORD Characteristics" + ";" + DiHeader[0] + DiHeader[1] + DiHeader[2] + DiHeader[3]; // Flags Unknown
        Retorno[1] = "DWORD TimeDateStamp" + ";" + TotalConversor.ConvertExaFechaEsamblado( DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
        Retorno[2] = "WORD MajorVersion" + ";" + TotalConversor.ConVertBaseDecimal( DiHeader[9] + DiHeader[8],16);
        Retorno[3] = "WORD MinorVersion" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[11] + DiHeader[10],16);
        Retorno[4] = "WORD NumberOfNamedEntries" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[13] + DiHeader[12],16); // El número de entradas de directorio inmediatamente después de la tabla que utilizan cadenas para identificar las entradas de Tipo, Nombre o Idioma 
        Retorno[5] = "WORD NumberOfIdEntries" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[15] + DiHeader[14],16); // El número de entradas del directorio inmediatamente después de las entradas de Nombre, que utilizan ID numéricos para las entradas de Tipo, Nombre o Idioma.
 
        return Retorno;
 
    } // 16 bytes
 
    public static string[] Resource_Directory_Node_Entry_8(string[] DiHeader) // Resource data descriptor  The .rsrc Section
    {
 
        string[] Retorno = new string[3];
 
        Retorno[0] = "DWORD Name Offset or Integer ID" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // determinado anteriormente  mirar???????
 
        string Binario = TotalConversor.ConVertByteExaBinary(DiHeader[7]);
 
      if (Binario.Substring(0, 1) == "1") { Retorno[2] = "NewDirectory"; DiHeader[7] = TotalConversor.HexQuitarBitAlto(DiHeader[7]) ; } else { Retorno[2] = "DataEntry"; }
 
        Retorno[1] = "DWORD Data Entry Offset or Sudirectory Offset" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];  // Bit alto 1. Los 31 bits inferiores son la dirección de otra tabla de directorio de recursos (el siguiente nivel hacia abajo).Bit alto 0. Dirección de una entrada de datos de recursos (una hoja).
 
        return Retorno;
 
    } // 8 bytes
 
    public static string[] Resource_Data_Entry_16(string[] DiHeader)  // The .rsrc Section
    {
 
        string[] Retorno = new string[4];
 
        Retorno[0] = "Data RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // La dirección de una unidad de datos de recursos en el área de datos de recursos
        Retorno[1] = "Size" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4],16);  // El tamaño, en bytes, de los datos de recursos a los que apunta el campo Data RVA.
        Retorno[2] = "Codepage" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8],16);  // La página de códigos que se utiliza para decodificar valores de puntos de código dentro de los datos de recursos. Normalmente, la página de códigos sería la página de códigos Unicode.
        Retorno[3] = "Reserved, must be 0" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
 
        return Retorno;
 
    } // 16 bytes
 
                                                 // String resource data
   // The string resource data consists of 16 string descriptors per section.Strings whose identifiers differ only in the bottom 4 bits are placed in the same section.
    public static string[] Resource_Directory_Node_Name_o_Data_String_2_64(string[] DiHeader) // Resource node name string The .rsrc Section
    {
 
        string[] Retorno = new string[3];
 
        int Longitud = 2 * (Convert.ToInt32(TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16)));  // este es un recuento de "WORD = 2" bytes X longitud
        Retorno[0] = "WORD Lenght" + ";" + Longitud.ToString(); // El tamaño de la cadena en bytes, sin incluir el campo de longitud en sí. 
        if (Longitud > 62) { Retorno[2] = "Nombre mas grande que 62"; Longitud = 62; } else { Retorno[2] ="Ok"; }
        ArraySegment<String> myArrSegMid = new ArraySegment<String>(DiHeader, 2, Longitud); ////  48
       //  Retorno[1] = "Unicode String" + ";" + TotalConversor.ConVertByteExaCadena(myArrSegMid.ToArray()); ;  // The variable-length Unicode string data, word-aligned. 
 
        Retorno[1] = "? Unicode String" + ";" + TotalConversor.HextoStringUnicode(string.Concat (myArrSegMid.ToArray()));   // The variable-length Unicode string data, word-aligned. UTF-16 little-endian sin carácter de fin de cadena.
 
 
        return Retorno;
 
    } // 64 bytes
 
 
 
 
 
 
 
 
 
 
 
 
    public static string[] RESOURSE_VS_VERSIONINFO_CABEZERA_6(string[] DiHeader) // //  30  VS_VERSIONINFO "VS_VERSION_INFO",StringFileInfo "StringFileInfo",StringTable "<language ID Un número hexadecimal de 8 dígitos unicode +4 idioma -4 página de códigos formato>",String ex:"ProductName",VarFileInfo "VarFileInfo",Var idioma y  página de códigos varios DWORDs COMPATIBLES.
    { //  DataDirectory
 
        string[] Retorno = new string[3];     
 
        Retorno[0] = "Long-" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16);  //  WORD La longitud, en bytes, de la estructura VS_VERSIONINFO 
        string LongHija = TotalConversor.ConVertBaseDecimal(DiHeader[3] + DiHeader[2], 16); //
        if (LongHija == "0") { LongHija = "LongHija 0" + ";" + LongHija; } else { LongHija = "LongHija-" + ";" + LongHija; }  //
        Retorno[1] = LongHija; // La longitud, en bytes, del VS_FIXEDFILEINFO y hijas  // WORD
        Retorno[2] =  TotalConversor.ConVertBaseDecimal( DiHeader[5] + DiHeader[4],16); // Es 1 si datos de texto y 0 si datos binarios
 
        return Retorno;
 
    } // 
 
 
 
 
    // Obtenemos el string y...  con 64 bytes creo que cubrimos casi todos
    // hemos separado la estructura original para controlar las longitudes variables de los string(s), a la vez que obtenemos el puntero a la siguiente estructura.
    public static string[] RESOURSE_VS_VERSIONINFO_Unicode_string_L_64(string[] DiHeader, int Inicio) // 
    { //  DataDirectory
        string[] Retorno = new string[3];
        string[] paso= TotalConversor.StringPading(DiHeader, Inicio);
 
        Retorno[0] = paso[0] +";-UnicodeL" ;  //  30  VS_VERSIONINFO "VS_VERSION_INFO",StringFileInfo "StringFileInfo",StringTable "<language ID Un número hexadecimal de 8 dígitos unicode +4 idioma -4 página de códigos formato>",String ex:"ProductName",VarFileInfo "VarFileInfo",Var idioma y  página de códigos varios DWORDs COMPATIBLES.
        Retorno[1] = "Puntero-;" + TotalConversor.ConvertStrimDecExa( paso[1]); // puntero a la siguiente estructura
        Retorno[2] = paso[2];  // si es igual a "ok"  todo salio perfecto....jeje
        return Retorno;
 
    } // 
 
 
 
    public static string[] RESOURSE_VS_VERSIONINFO_VS_FIXEDFILEINFO_52(string[] DiHeader) // 
    { //  DataDirectory
 
        string[] Retorno = new string[13];
 
        Retorno[0] = "DWORD dwSignature (FEEF04BD)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //	
        Retorno[1] = "DWORD dwStrucVersion" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   //El número de versión binaria  PRIMARIA Y SEGUNDARIA WORD WORD  / Version  Stored as 2 x 16 - bit values, e.g.  "00 00 01 00" &#8658; 1.0
        Retorno[2] = "DWORD dwFileVersionMS" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //versiónMS binaria del archivo. se usa con dwFileVersionLS para formar un valor de 64 bits que se usa para comparaciones numéricas. / File version (upper 32-bit) Stored as 2 x 16-bit values, e.g. "00 00 06 00" &#8658; 6.0
        Retorno[3] = "DWORD dwFileVersionLS" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //versiónLS binaria del archivo. se usa con dwFileVersionMS para formar un valor de 64 bits que se usa para comparaciones numéricas. / File version (lower 32-bit) Stored as 2 x 16-bit values, e.g. "02 40 70 17" &#8658; 6000.16386
        Retorno[4] = "DWORD dwProductVersionMS" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //Los 32 bits más significativos del número de versión binaria del producto con el que se distribuyó este archivo. Este miembro se usa con dwProductVersionLS para formar un valor de 64 bits que se usa para comparaciones numéricas. 
        Retorno[5] = "DWORD dwProductVersionLS" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  //Los 32 bits MENOS significativos del número de versión binaria del producto con el que se distribuyó este archivo. Este miembro se usa con dwProductVersionMS para formar un valor de 64 bits que se usa para comparaciones numéricas. 
        Retorno[6] = "DWORD dwFileFlagsMask" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];  //Contiene una máscara de bits que especifica los bits válidos en dwFileFlags. Un bit es válido solo si se definió cuando se creó el archivo.File flags bitmask 0x0000003f
        Retorno[7] = "DWORD dwFileFlags" + ";" + RESOURSE_VS_FIXEDFILEINFO_dwFileFlags(DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28]);  //Contiene una máscara de bits que especifica los atributos booleanos del archivo. Este miembro puede incluir uno o más de los siguientes valores. 
        Retorno[8] = "DWORD dwFileOS" + ";" + RESOURSE_VS_FIXEDFILEINFO_dwFileOS(DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32]);  //El sistema operativo para el que se diseñó este archivo. Este miembro puede tener uno de los siguientes valores.
        Retorno[9] = "DWORD dwFileType" + ";" + RESOURSE_VS_FIXEDFILEINFO_dwFileType(DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36]);  //El tipo general de archivo. Este miembro puede tener uno de los siguientes valores. Los demás valores están reservados. 
        Retorno[10] = "DWORD dwFileSubtype" + ";" + (DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]);  //La función del archivo. Los valores posibles dependen del valor de dwFileType. Para todos los valores de dwFileType que no se describen en la siguiente lista, dwFileSubtype es cero.
        if (Retorno[9].Contains("VFT_DRV")){Retorno[10] = "DWORD dwFileSubtype" + ";" + RESOURSE_VS_FIXEDFILEINFO_VFT_DRV_dwFileSubtype_(DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]); }
        if (Retorno[9].Contains("VFT_FONT")) { Retorno[10] = "DWORD dwFileSubtype" + ";" + RESOURSE_VS_FIXEDFILEINFO_VFT_FONT_dwFileSubtype_(DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]); }
        Retorno[11] = "DWORD dwFileDateMS" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //Los 32 bits más significativos de la fecha y hora de creación binaria de 64 bits del archivo.
        Retorno[12] = "DWORD dwFileDateLS" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //Los 32 bits menos significativos de la fecha y hora de creación binaria de 64 bits del archivo.
 
        return Retorno;
 
    } // 
 
    public static string[] RESOURSE_VS_VERSIONINFO_VS_MUI_(string[] DiHeader) // UNICODE Literal TXT
    { //  DataDirectory
 
        string[] Retorno = new string[13];
 
        Retorno[0] = "DWORD Signature (FECDFECD)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //	
        Retorno[1] = "DWORD Size" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   //
        Retorno[2] = "DWORD RC Config Version 10000 " + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //
        Retorno[3] = "DWORD Unknown" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //
        Retorno[4] = "DWORD File type 0x00000011 = normal 0x00000012 = MUI file" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //
        Retorno[5] = "DWORD System attributes" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  //
        Retorno[6] = "DWORD Ultimate fallback location 0x01 = internal 0x02 = external" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];  //
        Retorno[7] = "OWORD Service Checksum" + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];  // 16 BYTES 8 WORD
        Retorno[8] = "OWORD Checksum" + ";" + DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32];  // 16 BYTES 8 WORD
        Retorno[9] = "DOWORD Unknown" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 24 BYTES 12 WORD
        // Value descriptors
        Retorno[10] = "DWORD Main name type data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //AVI FTR ORDERSTREAM TYPELIB UIFILE XML MUI       
        Retorno[11] = "DWORD Main name type data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
        Retorno[12] = "DWORD Main ID types data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //      1-24                                                  Retorno[13] = "DWORD Main ID types data size" + ";" DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 
        Retorno[14] = "DWORD MUI name type data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //   MOFTYPE MUI WEVT_TEMPLATE
        Retorno[15] = "DWORD MUI name type data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
        Retorno[16] = "DWORD MUI ID types data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
        Retorno[17] = "DWORD MUI ID types data size" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 24 BYTES 12 WORD
        Retorno[18] = "DWORD Language data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //    
        Retorno[19] = "DWORD Language data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
        Retorno[20] = "DWORD Ultimate fallback language data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
        Retorno[21] = "DWORD Ultimate fallback language data size" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
        // VALUE DATA 64-bit aligned
 
        return Retorno;
 
    } // 
 
 
    public static string[] RESOURSE_VS_VERSIONINFO_VS_WEVT_TEMPLATE_(string[] DiHeader) // UNICODE Literal TXT
    { //  DataDirectory
        string[] Retorno = new string[6];
 
        Retorno[0] = "DWORD Signature (CRIM)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //	
        Retorno[1] = "DWORD Size" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   // Including the compiled resource instrumentation manifest header
        Retorno[2] = "WORD Major version 3" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //
        Retorno[3] = "WORD Minor version 1" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //
        Retorno[4] = "DWORD Number of event providers" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //
        Retorno[5] = "DEWORD*Number Array of event provider descriptors" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  // 20 BYTES  10 WORD
 
 
        return Retorno;
 
    } // 
 
    public static string[] RESOURSE_VS_VERSIONINFO_TABLA_WEVT_TEMPLATE_(string[] DiHeader) // UNICODE Literal TXT
    { //  DataDirectory
        string[] Retorno = new string[2];
        Retorno[0] = "ODWORD  Contains a GUID" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //	16 BYTES 8 WORD
        Retorno[1] = "DWORD  data offset " + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   // start of the instrumentation manifest
 
 
        return Retorno;
 
    } // 
 
    public static string[] Resource_MESSAGE_Table_Header_4(string[] DiHeader)  // The .rsrc Section The message-table header (MESSAGE_RESOURCE_DATA) is variable of size and consists of
    {
 
        string[] Retorno = new string[1];
 
        Retorno[0] = "NumberNodeTabla" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // Number of message-table entry descriptors
 
        return Retorno;
 
    } // 4 bytes
 
    public static string[] Resource_MESSAGE_Table_Entry_12(string[] DiHeader)  // The .rsrc Section The message-table entry descriptor (MESSAGE_RESOURCE_BLOCK) is 12 bytes of size and consist of
    {
 
        string[] Retorno = new string[12];
 
        Retorno[0] = "DWORD IdPrimer" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // Identificador del primer mensaje
        Retorno[1] = "DWORD IdUltimo" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]; // Identificador del último mensaje
        Retorno[2] = "DWORD OffsetPrimer" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8]; // Offset of the first message
 
        return Retorno;
 
    } // 12 bytes
 
    public static string[] Resource_MESSAGE_Entry_4_(string[] DiHeader)  // The .rsrc Section The message-table string entry (MESSAGE_RESOURCE_ENTRY) is variable of size and consists of:
    {
 
        string[] Retorno = new string[3];
 
        Retorno[0] = "WORD Size" + ";" + DiHeader[1] + DiHeader[0]; // 
        Retorno[1] = "WORD Flags" + ";" + DiHeader[3] + DiHeader[2]; // 0x00 = extended ASCII string with codepage /  0x01 = UTF-16 string
        Retorno[2] = "? String_L_Padin32" + ";" + "?"; // 
        return Retorno;
 
    } // 4 + ?
 
 
 
 
 
 
 
 
    public static string[] IMAGE_DELAY_IMPORT_DESCRIPTOR_32(string[] DiHeader) // The .idata Section (Image Only)
    { //  DataDirectory
 
        string[] Retorno = new string[8];
 
        Retorno[0] = "Attributes,Must be zero." + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  // 1  31 reservado
        Retorno[1] = "Name RVA,of the name of the DLL" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];
        Retorno[2] = "Module Handle RVA, of the module handle ." + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];
        Retorno[3] = "Delay Import Table RVA, of the delay-load import address table IAT." + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
        Retorno[4] = "Delay Import Name Table RVA, de la tabla de nombres  Esto coincide con el diseño de la tabla de nombres de importación." + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];
        Retorno[5] = "Bound Delay Import Table RVA, of the bound delay-load address table, if it exists." + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];
        Retorno[6] = "Unload Delay Import Table RVA, tabla de direcciones de carga , si existe. copia exacta de la tabla de direcciones de importación" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];
        Retorno[7] = "Time Stamp,The timestamp of the DLL." + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];
 
        return Retorno;
 
    } // 32 Bytes 
}