function test(var1, var2=0xFFFF)
{
 alert("var2 "+var2);
}

test();

 <?php
    function doFoo($Name = "Paul") {
        return "Foo $Name!\n";
    }

    doFoo();
    doFoo("Paul");
    doFoo("Andrew");
?> 

var Base64_chars="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

var Base64_nostd="9ryoAuwh4RvMDPYKNltWUTaEqnBmbcSZFxfGg7iJj6QsVkOXzdH0C1p2e35L8I+/=";

/*****************************************************************************
Base64: My_btoa y My_atob

 2012-07-02


Implementación de Base64 en javascript.

http://devel.cable-modem.org/

Este código es de dominio público (sin derechos de autor).
Puedes hacer lo que desees con él.


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



function My_atob(base64_data, table)
{
 var binary64="";
 var binary="";

 if(typeof(base64_data)!="string")return "";
 if(!(base64_data.length>0))return "";


 var tmp="";
 var c="";
 for(var x=0;x<base64_data.length;x++)
 {
  c=base64_data.charAt(x);

  //These padding characters should be ignored:
  ///
    if(c=="=" || c==" " || c=="\t" || c=="\r" || c=="\n")continue;

  //Otherwise, look for the index in which the specified character is.
  //That will be the value of the Base64 current character.
  else
   c=table.indexOf(c);

  binary64+=StrPad(str=c.toString(2),padchar="0",paddedstrlen=6,direction="l");
  
  if(binary64.length>=8)
  {
   binary+=String.fromCharCode(parseInt(binary64.substring(0,8),2));

   binary64=binary64.substring(8,binary64.length);
  }
 }

 return binary;
}






//Converts a raw "binary" data string into Base64 data:
///
function My_btoa(binary_data, table)
{
 var Base64_TBL=table.split("");

 //This will contain our resulting converted data
 ///
  var base64="";

 //Check that the data is a string and that its length is not 0:
 ///
  if(typeof(binary_data)!="string")return "";
  if(!(binary_data.length>0))return "";


 //Temporary 32-bit DWORD:
 ///
  var tmp="";


 //4-byte temporary Base64 chunk for each 3 bytes of data, and/or plus padding if necessary:
 ///
  var tm2="";

 //Number of '=' padding characters, to avoid generating Base64 charactes that should be padding to begin with:
 //Number of '=' characters if there is no further data in size divisible exactly by 3:
 ///
  var padcount="";


 //This loop advances in groups of 3 because 3 "binary" letters
 //produce 4 Base64 letters:
 ///
  for(var x=0;x<binary_data.length;x+=3)
  {
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   ///
    tmp=binary_data.charCodeAt(x)<<24;         //bits 31-24

    if(x+1<binary_data.length)
    tmp|=binary_data.charCodeAt(x+1)<<16;   //bits 23-16
    else padcount++;                    //If there's no data, increase padding and this bit group is 0 automatically

    if(x+2<binary_data.length)
    tmp|=binary_data.charCodeAt(x+2)<<8;    //bits 15-8
    else padcount++;                    //If there's no data, increase padding and this bit group is 0 automatically

                                               //bits 7-0 are 0 always

                                              
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"


    //Shift 8 bits left to re-align all bit values in an order
    //proper for the 6 bits of Base64.
    //
    //This will NOT discard the first 2 bits of the DWORD, but anyway
    //the bits of the next byte of data, if present (byte 4),
    //belong to the next group of 3 bytes and are useless for the
    //current 32-bit run:
    ///
     tmp>>=8;   //tmp is a 32-bit DWORD here


    //"Flush" past, now useless data, before using the buffer again (might not be necessary
    //in C or assembly since the data in those languages will always be overwritten either by
    //data or padding; but it is required in javascript because the string cannot be handled
    //so freely in such language).
    ///
     tm2="";


     var sshl=6;  //I thought that this bit shifting was going to be dynamic, but after the adjusting above
                  //and the bit masking below inside the loop, it isn't necessary at all.


     for(var y=0;y<4;y++)
     {
      //Get bits 31-24, then 23-16 and 15-8 and use them as index for the third, second
      //and first Base64 characters, respectively:
      ///

      //Save the corresponding Base64 character, backwards, or if we are in a range in which
      //we previously detected that there was no data available for bytes 2 of 3 and/or 3 of 3,
      //just add padding.
      //
      //In other words, if the count of required padding characters is 0 (3 original bytes were
      //present for this loop run), or if the count of padding characters is not 0 and y is
      //in a range above/outside that of the padding characters to generate, then save a Base64
      //indexed character.
      //
      //Otherwise, we are in a byte range for padding, and we must generate and save a padding character
      //(it could and should only happen at the very end of the whole data buffer):
      ///
       if(padcount==0 || (padcount!=0 && y>padcount-1))
       {
        tm2=Base64_TBL[tmp&63]+tm2;
       }
        else tm2=tm2+"=";


      //Keep shifting bits. We have saved backwards because in this way we
      //reduce the amount of bit shifting and bit masking required to get
      //the 6 bits required for each Base64 character, and still we can get
      //each Base64 character as soon as possible, as soon as its offset
      //is available to us.
      ///
       tmp>>=6;
     }

   //Save this chunk of Base64 characters:
   ///
    base64+=tm2;
  }

 return base64;
}






function StrPad(str,padchar,paddedstrlen,direction)
{
 //If no direction was specified, the default action is
 //to pad leftmost:
 ///
  if(!direction)direction="l";

 
 //Don't allow empty padding character variable or a bad final padded length
 //because it would cause an infinite loop:
 ///
  if(typeof(paddedstrlen)!="number" || typeof(padchar)!="string")return str;
  if(!(padchar.length>0) || paddedstrlen<=0)return str;


 if(direction.toLowerCase()=="r")
 {
   while(str.length<paddedstrlen)
   {
    str=str+padchar.charAt(0);
   }
 }
  else
  {
    while(str.length<paddedstrlen)
    {
     str=padchar.charAt(0)+str;
    }
  }


 return str;
}

function mod(modrm){
 var mod=parseInt("11000000b", 2);
 var mod_val=(modrm&mod)>>6;
 return mod_val;
}



function reg(modrm){
 var reg=parseInt("00111000", 2);
 var reg_val=(modrm&mod)>>3;
 return reg_val;
}


function rm(modrm){
 var rm=parseInt("00000111", 2);
 var rm_val=(modrm&rm);
 return rm_val;
}



function scale(sib){
 var scale = parseInt("11000000b", 2);
 var scale_val=(sib&scale)>>6;
 return scale_val;
}


function index(sib){
 var index = parseInt("00111000b", 2);
 var index_val=(sib&index)>>3;
 return index_val;
}


function base(sib){
 var base  = parseInt("00000111b", 2);
 var base_val=sib&base;
 return base_val;
}



function xor_16()
{
    var ctr=0x00;

    var str="";
    for(var modrm=0; modrm<256; modrm++)
    {
     str+="db 0x31,"+modrm;

     if(mod(modrm)==0)
     {
      if(rm(modrm)==6)
       str+=",0,0\n";
      else
      {
       str+="\n";
       continue;
      }
     }
      else if(mod(modrm)==1)
      {
       str+=",0\n";
       continue;
      }
       else if(mod(modrm)==2)
       {
        str+=",0,0\n";
        continue;
       }
        else if(mod(modrm)==3)
        {
         str+="\n";
         continue;
        }
    }

 return str;
}

//This function makes the VGA card enter in
//standard 320x200 256-color MCGA mode,
//without using the BIOS.
//
//It follows the following sequence:
//
// 1. Turns off monitor output to completely avoid flicker,
//    frequency/synchrony issues while setting the video mode,
//    and apparently making the video mode switching much faster
//    from text to graphics.
//
// 2. Configures the Miscellaneous Output Register.
//
// 3. Configures the Feature Control Register.
//
// 4. Write the 5 Sequencer registers.
//
// 5. Unprotect CRTC registers 0-7.
//
// 6. Writes the 25 CRTC registers.
//
// 7. Protects CRTC registers 0-7.
//
// 8. Writes the 9 Graphics Controller Registers.
//
// 9. Writes the Attribute Controller Registers.
//    Here's an optimization: From its 21 registers, only
//    registers 16 to 20 are written. Registers 0 to 15
//    are left unchanged because those palette registers are
//    not useful for MCGA 320x200x256, so we skip writing those.
//
//10. Enable reads to the palette by setting bit 5 of the
//    Attribute Controller Index Register at 0x3C0, to 1.
//
//11. Turn back on monitor output to make use of the graphics mode.
//
//This sequence takes the best from all of the other programming sequences floating around
//for manually entering mode 13h, and thus has original-research optimizations
//from me (skipping configuration the 16-color palette of the Attribute Controller),
//and avoiding inferior ways of doing things (wait for vertical retrace, instead of
//doing it much better by disabling hardware video output, while reconfiguring
//the registers), etc. And it is much, much more documented and easy to read/understand,
//with nice and elegant public domain low level standard VGA "API" functions.
//
//This program does NOT reconfigure BIOS video mode metrics in the BDA, nor clears
//the screen after setting the video mode, just because those tasks are entirely
//apart from the low level hardware programming shown here. That would just add to the
//bulk of this demo program, and it will be programmed by me, but in a different, yet
//equally reusable/combinable "API" package.
///
function set_mode_MCGA_320x200x256()
{
 push $WIDEAX;
 push $WIDEBX;
 push $WIDECX;
 push $WIDESI;

 //Write to Color register address in all cases
 //that apply to our interfacing functions:
 ///
  $BX=0000000001000000b;


 //Turn monitor output off to be nicer with older
 //and delicate monitors while fiddling with the configuration:
 ///
  stdVGA_Sequencer_Monitor_Off();


 //We want to set this register to clear its bit 0,
 //to enforce activating I/O register addresses for
 //color video modes, and the rest of its configurations:
 ///
  $AL=[CGA_320x200x256Gen__MiscOutputReg];
  stdVGA_set_Miscellaneous_Output_Register();


 //Write the Feature Control Register:
 ///
  $AL=[CGA_320x200x256Gen__FeatureControlReg];
  //$BX=0000000001000000b;  //Write to Color register address
  stdVGA_set_Feature_Control_Register();


 //Write the Sequencer registers:
 ///
  $CH=0;  //Index of first register to write
  $CL=5;  //Number of registers to write
  $WIDESI=CGA_320x200x256SequencerRegs;
  stdVGA_set_Sequencer_regs();


 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers

  //First unprotect registers 0-7:
  ///
   $CL=00000000b;          //Do Unprotect
   //$BX=0000000001000000b;  //Use Color I/O port address
   stdVGA_protect_unprotect_CRTC_regs();



  //Write the CRTC registers:
  ///
   $CH=0;   //Index of first register to write
   $CL=25;  //Number of registers to write
   //$BX=0000000001000000b;  //Use Color I/O port address
   $WIDESI=CGA_320x200x256CRTCRegs;
   stdVGA_set_CRTC_regs();



  //Finally, protect registers 0-7 again:
  ///
   $CL=10000000b;          //Do Protect
   //$BX=0000000001000000b;  //Use Color I/O port address
   stdVGA_protect_unprotect_CRTC_regs();


 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers



 //Write the Graphics Controller registers:
 ///
  $CH=0;  //Index of first register to write
  $CL=9;  //Number of registers to write
  $WIDESI=CGA_320x200x256GraphicsRegs;
  stdVGA_set_Graphics_regs();



 //Write the Attribute Controller registers. We will
 //try skipping the 16-color palette registers here,
 //since MCGA 320x200@256 colors uses the DAC instead
 //of those registers, and these registers don't care
 //in this mode:
 ///
  //Address bits of attribute flip/flop to reset it by reading it
  ///
   //$BX=0000000001000000b;
   $CH=16;     //Index of first register to write
   $CL=21-16;  //Number of registers to write
   $WIDESI=CGA_320x200x256AttributeRegs+16;
   stdVGA_set_Attribute_regs();



  //Enable the capability of reading the palette.
  //Otherwise, the screen will stay absolutely black!:
  ///
   stdVGA_set_Attribute_regs__EnablePalette();


 //Turn monitor output on (this assumes that the register
 //set values we are using keep the Sequencer's Screen Off bit
 //off at all times, to not defeat the very purpose of this
 //"protection"):
 ///
  stdVGA_Sequencer_Monitor_On();


 pop $WIDESI;
 pop $WIDECX;
 pop $WIDEBX;
 pop $WIDEAX;
}

set_mode_MCGA_320x200x256:
push eax
push ebx
push ecx
push esi



mov bx,0000000001000000b;



call stdVGA_Sequencer_Monitor_Off;


mov al,[CGA_320x200x256Gen__MiscOutputReg];
call stdVGA_set_Miscellaneous_Output_Register;


mov al,[CGA_320x200x256Gen__FeatureControlReg];
call stdVGA_set_Feature_Control_Register;



mov ch,0;
mov cl,5;
mov esi,CGA_320x200x256SequencerRegs
call stdVGA_set_Sequencer_regs;



mov cl,00000000b;
call stdVGA_protect_unprotect_CRTC_regs;


mov ch,0;
mov cl,25;
mov esi,CGA_320x200x256CRTCRegs
call stdVGA_set_CRTC_regs;



mov cl,10000000b;
call stdVGA_protect_unprotect_CRTC_regs;



mov ch,0;
mov cl,9;
mov esi,CGA_320x200x256GraphicsRegs
call stdVGA_set_Graphics_regs;



mov ch,16;
mov cl,5;
mov esi,CGA_320x200x256AttributeRegs+16;
call stdVGA_set_Attribute_regs;


call stdVGA_set_Attribute_regs__EnablePalette;



call stdVGA_Sequencer_Monitor_On;



pop esi
pop ecx
pop ebx
pop eax
ret

function sys_get_args()
{
 asm pushad

  $ESI = 0x81;       ;//Start of command-line string
  $EDI = sys_argv;
  $CL  = byte[0x80]; ;//Size of command-line string


  while($CL != 0)
  {
    if( byte[$ESI]!=0x20 && byte[$EDI]!=0x0D )
    {
     dword[sys_argc]++;

     dword[$EDI]=$ESI;
     $EDI+=4;

     sys_args_last_arg_char();
     dword[$EDI]  = $EAX;
     dword[$EDI] -= $ESI;
     $CL-=[$EDI];


     $ESI=$EAX;
     $EDI+=4;
     continue;
    }


   ;//These 2 instructions are only in case
   ;//the characters are 0x20 or 0x0D, and the
   ;//"continue" just above avoids it from being
   ;//run if we processed actual characters in this
   ;//iteration:
   ;;
    $ESI++;
    $CL--;
  }

 asm popad
}



align 16                               ;//DEBUG STRING
db "int argc void *argv             "  ;//DEBUG STRING
 sys_argc dd 0
 sys_argv times 128 dd 0

align 16                               ;//DEBUG STRING
db "       int argc void *argv {END}"  ;//DEBUG STRING




function /*$EAX */sys_args_last_arg_char()
{
 asm push ecx


  $EAX=$ESI;

  while($CL != 0)
  {
    if( byte[$EAX]==0x20 || byte[$EAX]==0x0D )
    break;

    $EAX++;
    $CL--;
  }

 asm pop ecx
}

sys_get_args:
  pushad
    mov esi,0x81
    mov edi,sys_argv
    mov cl,[0x80]




   .while_ln28:
   cmp cl,0
   jz .while_ln28_end
       cmp byte[esi],0x20
       je .not_if_ln28
       cmp byte[esi],0x0D
       je .not_if_ln28

       inc dword[sys_argc]

       mov dword[edi],esi
       add edi,4


       call sys_args_last_arg_char

       mov dword[edi],eax
       sub dword[edi],esi
       sub cl,[edi]

        mov esi,eax
        add edi,4

       jmp .while_ln28

     .not_if_ln28:

   ;//These 2 instructions are only in case
   ;//the characters are 0x20 or 0x0D, and the
   ;//"continue" just above avoids it from being
   ;//run if we processed actual characters in this
   ;//iteration:
   ;;
    inc esi
    dec cl

   jmp .while_ln28
   .while_ln28_end:

  popad
ret



align 16
db "int argc void *argv             "
 sys_argc dd 0
 sys_argv times 128 dd 0

align 16
db "       int argc void *argv {END}"



sys_args_last_arg_char:
  push ecx
    mov eax,esi

   .while_ln74:
   cmp cl,0
   jz .while_ln74_end
      cmp byte[eax],0x20
      je .while_ln74_end
      cmp byte[eax],0x0D
      je .while_ln74_end


      inc eax
      dec cl

   jmp .while_ln74
   .while_ln74_end:

  pop ecx
ret

;NOTA: Ensamblar con el comando:
;
;        NASM pehead.asm -o pehead.exe


EXE_start:

bits 32

alig equ 16


%define round(n, r) (((n+(r-1))/r)*r)



DOS_stub_start:
  db 'MZ'


  times 0x3A db 0


  dd PEhead


DOS_stub_end:
DOS_stub_SZ equ (DOS_stub_end-DOS_stub_start)


PE_head_start:
  PEhead:

  PEhead.Signature            db 'P','E',0,0

  PEhead.Machine              dw 0x14C

  PEhead.NumberOfSections     dw 1

  PEhead.TimeDateStamp        dd 0

  PEhead.PointerToSymbolTable dd 0

  PEhead.NumberOfSymbols      dd 0

  PEhead.SizeOfOptionalHeader dw 4

  PEhead.Characteristics      dw 0x0103

PE_head_end:
PE_head_SZ equ (PE_head_end-PE_head_start)



Opt_Head_start:
  OptHead:

  OptHead.Magic                   dw 0x10B
  OptHead.MajorLinkerVersion      db 8
  OptHead.MinorLinkerVersion      db 0
  OptHead.SizeOfCode              dd round(codesize,alig) ;1024 ;Code_SZ
  OptHead.SizeOfInitializedData   dd 0
  OptHead.SizeOfUninitializedData dd codesize ;1024
  OptHead.AddressOfEntryPoint     dd PrgEntry
  OptHead.BaseOfCode              dd codesize ;1024
  OptHead.BaseOfData              dd PrgEntry
  OptHead.ImageBase               dd 0x400000
  OptHead.SectionAlignment        dd alig
  OptHead.FileAlignment           dd alig
  OptHead.MajorOSVersion          dw 4
  OptHead.MinorOSVersion          dw 0
  OptHead.MajorImageVersion       dw 0
  OptHead.MinorImageVersion       dw 0
  OptHead.MajorSubsystemVersion   dw 4
  OptHead.MinorSubsystemVersion   dw 0
  OptHead.Win32VersionValue       dd 0
  OptHead.SizeOfImage             dd round(hdrsize,alig)+round(codesize,alig) ;1024 ;EXE_SZ
  OptHead.SizeOfHeaders           dd round(hdrsize,alig) ;Headers_SZ
  OptHead.Checksum                dd 0
  OptHead.Subsystem               dw 2
  OptHead.DllCharacteristics      dw 0
  OptHead.SizeOfStackReserve      dd 0
  OptHead.SizeOfStackCommit       dd 0
  OptHead.SizeOfHeapReserve       dd 0
  OptHead.SizeOfHeapCommit        dd 0
  OptHead.LoaderFlags             dd 0
  OptHead.NumberOfRvaAndSizes     dd 3
    OptHead.ExportTable.VirtualAddress dd 0
    OptHead.ExportTable.Size           dd 0

    OptHead.ImportTable.VirtualAddress dd ImportDirectoryTable
    OptHead.ImportTable.Size           dd ImportDirectoryTable_SZ

    OptHead.ResourceTable.VirtualAddress dd ResourceTable
    OptHead.ResourceTable.Size           dd 4096 ;ResourceTable_SZ

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0
Opt_Head_end:
Opt_Head_SZ equ (Opt_Head_end-Opt_Head_start)



hdrsize equ $ - $$



Headers_SZ equ $-$$ ;(Opt_Head_SZ+PE_head_SZ+DOS_stub_SZ)






db ".code"
times 3 db 0

_virtualsize dd 2048
_virtualaddress dd PrgEntry
_sizeofrawdata dd 2048
_pointertorawdata dd PrgEntry
_pointertorelocations dd 0
_pointertolinenumbers dd 0
_numberofrelocations dw 0
_numberoflinenumbers dw 0
_characteristics dd 0x60000020



db ".rsrc"
times 3 db 0

virtualsize dd 2048
virtualaddress dd ResourceTable
sizeofrawdata dd 2048
pointertorawdata dd ResourceDirectoryEntry
pointertorelocations dd 0
pointertolinenumbers dd 0
numberofrelocations dw 0
numberoflinenumbers dw 0
characteristics dd 0x50000040





align 16
PrgEntry:
align 16
    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]

    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]

    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]

    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]
ret


align 4
str1 db "Stringz 1",0
align 4
str2 db "Srins 2",0
align 4
str3 db "Strins a3",0


;align 1048576



align 16
db "[EOF]",0










align 16
ResourceTable:




;align 8
;






ResourceDirectoryEntry:


ResourceDirectoryTable0:
  ResourceDirectoryTable0.Characteristics     dd 0
  ResourceDirectoryTable0.Time_DateStamp      dd 0x49DDFF5E
  ResourceDirectoryTable0.MajorVersion        dw 0
  ResourceDirectoryTable0.MinorVersion        dw 0
  ResourceDirectoryTable0.NumberOfNameEntries dw 0
  ResourceDirectoryTable0.NumberOfIDEntries   dw 1

    ResourceDirectoryEntry1:
      ResourceDirectoryEntry1.IntegerID           dd 3
      ResourceDirectoryEntry1.EntryRVA            dd 0x80000000+ResourceDirectoryTable2 ;(ResourceDirectoryTable2-ResourceTable)

        ResourceDirectoryTable2:
          ResourceDirectoryTable2.Characteristics     dd 0
          ResourceDirectoryTable2.Time_DateStamp      dd 0x49DDFF5E
          ResourceDirectoryTable2.MajorVersion        dw 0
          ResourceDirectoryTable2.MinorVersion        dw 0
          ResourceDirectoryTable2.NumberOfNameEntries dw 0
          ResourceDirectoryTable2.NumberOfIDEntries   dw 1


            ResourceDirectoryEntry3:
              ResourceDirectoryEntry3.IntegerID           dd 1
              ResourceDirectoryEntry3.EntryRVA            dd ResourceDirectoryTable4 ;(ResourceDirectoryTable4-ResourceTable)


                ResourceDirectoryTable4:
                  ResourceDirectoryTable4.Characteristics     dd 0
                  ResourceDirectoryTable4.Time_DateStamp      dd 0x49DDFF5E
                  ResourceDirectoryTable4.MajorVersion        dw 0
                  ResourceDirectoryTable4.MinorVersion        dw 0
                  ResourceDirectoryTable4.NumberOfNameEntries dw 0
                  ResourceDirectoryTable4.NumberOfIDEntries   dw 1

                    ResourceDirectoryEntry5:
                      ResourceDirectoryEntry5.IntegerID           dd 0
                      ResourceDirectoryEntry5.EntryRVA            dd ResourceDataEntry6 ;(ResourceDataEntry6-ResourceTable)


                        ResourceDataEntry6:
                          ResourceDataEntry6.DataRVA                  dd vsico
                          ResourceDataEntry6.Size                     dd 1024 ;vsico_SZ
                          ResourceDataEntry6.CodePage                 dd 0
                          ResourceDataEntry6.Reserved                 dd 0



;ResourceDirectoryEntry:
;  ResourceDirectoryEntry.NameRVA             dd namerva
;  ResourceDirectoryEntry.IntegerID           dd 3
;  ResourceDirectoryEntry.DataEntryRVA        dd ResourceDirectoryTable
;  ResourceDirectoryEntry.SubdirectoryRVA     dd 0
;
;
;
;ResourceDirectoryTable:
;  ResourceDirectoryTable.Characteristics     dd 0
;  ResourceDirectoryTable.Time_DateStamp      dd 0
;  ResourceDirectoryTable.MajorVersion        dw 8
;  ResourceDirectoryTable.MinorVersion        dw 0
;  ResourceDirectoryTable.NumberOfNameEntries dw 1
;  ResourceDirectoryTable.NumberOfIDEntries   dw 1
;
;
;
;ResourceDataEntry:
;  ResourceDataEntry.DataRVA                  dd vsico
;  ResourceDataEntry.Size                     dd vsico_SZ
;  ResourceDataEntry.CodePage                 dd 0
;  ResourceDataEntry.Reserved                 dd 0



align 16
vsico:
;incbin "bc.ico"

vsico_SZ equ $-vsico


ResourceTable_SZ equ $-ResourceTable

















ImportDirectoryTable:
ImportDirectoryTable_start:
   ImportTable.ImportLookupTableRVA_array0  dd ImportLookupTable_array0
   ImportTable.Time_DateStamp_array0        dd 0
   ImportTable.ForwarderChain_array0        dd 0
   ImportTable.NameRVA_array0               dd DLL_name_array0
   ImportTable.ImportAddressTableRVA_array0 dd ImportAddressTable_array0

   ImportTable.ImportLookupTableRVA_array1  dd 0
   ImportTable.TimeDateStamp_array1         dd 0
   ImportTable.ForwarderChain_array1        dd 0
   ImportTable.NameRVA_array1               dd 0
   ImportTable.ImportAddressTableRVA_array1 dd 0





ImportDirectoryTable_end:
ImportDirectoryTable_SZ equ (ImportDirectoryTable_end-ImportDirectoryTable_start)
	

ImportAddressTable_array0:
   ImportAddressTable.1_array0 dd Hint_NameTable_array0 ;0x80000000+477
   ImportAddressTable.2_array0 dd 0


ImportLookupTable_array0:
   ImportLookupTable.Ordinal_Name_OrdinalNum_array0 dd Hint_NameTable_array0 ;0x80000000+477
   ImportLookupTable.Hint_NameTableRVA_array0       dd 0




Hint_NameTable_array0:
   dw 0x1DC
   db "MessageBoxA",0



DLL_name_array0:
db "USER32.dll",0



codesize equ $ - PrgEntry


namerva db "ICON",0


EXE_end:
EXE_SZ equ round((EXE_end-EXE_start),alig)

Code_SZ equ round(($-PrgEntry),alig)