How to flash program memory?

unsigned short Eeprom_ReadWord(unsigned short addressHi, unsigned short  pushAddress) {
   unsigned short ushResult;
   register int eedata_addr; 
   register int eedata_val; 
   
   TBLPAG = addressHi; // __builtin_tblpage()
   eedata_addr = (unsigned short)pushAddress; // __builtin_tbloffset()
   __asm__("TBLRDL [%[addr]], %[val]" : [val]"=r"(eedata_val) : [addr]"r"(eedata_addr)); 
  
   ushResult = eedata_val; 
   return (ushResult);
}
void Eeprom_WriteWord(unsigned short addressHi, unsigned short pushAddress, unsigned short ushValue) {
   
   TBLPAG = addressHi;
   NVMADRU = addressHi; // Write address of word to be erased into NVMADRU, NVMADR registers.
   NVMADR = (unsigned short)pushAddress;
   NVMCON = ERASE_WORD; // Setup NVMCON register to erase one EEPROM word.
   
   //PROTECT_CODE_FROM_INTERRUPTS_START // Disable interrupts while the KEY sequence is written
      NVMKEY = 0x55; // Write the KEY sequence step1
      NVMKEY = 0xAA; // step2
      NVMCONbits.WR = 1; // Start the erase cycle
   //PROTECT_CODE_FROM_INTERRUPTS_STOP // Enable interrupts
   
   while (NVMCONbits.WR == 1); // wait for the EEPROM
   
   NVMCON = WRITE_WORD; // Setup NVMCON register to write one EEPROM word. 
   {
      register int eedata_addr; 
      register int eedata_val; 
      
      eedata_addr = (unsigned short)pushAddress; // write low word of address
      eedata_val = ushValue; // write data
      
      __asm__ volatile ("TBLWTL %[val], [%[addr]]" : [val]"+r"(eedata_val) : [addr]"r"(eedata_addr));
   }
   
   //PROTECT_CODE_FROM_INTERRUPTS_START // Disable interrupts while the KEY sequence is written
      NVMKEY = 0x55; // Write the KEY sequence step1
      NVMKEY = 0xAA; // step2
      NVMCONbits.WR = 1; // Start the erase cycle
   //PROTECT_CODE_FROM_INTERRUPTS_STOP // Enable interrupts
   
   while (NVMCONbits.WR == 1); // wait for the word to be written
   
   // no proper watchdog protection in the 2 while loops
   // no proper check if bytes are written correctly by re-reading them
}

value = Eeprom_ReadWord(0x0000, 0x0002);
Eeprom_WriteWord(0x007F, 0xFC00, 0x0001);

_LoadAddr:	;W0=NVMADRU,W1=NVMADR - no return values
	mov	W0,NVMADRU
	mov	W1,NVMADR
	
	return
	
;***************************************************************		
_WriteMem:	;W0=NVMCON - no return values
	mov	W0,NVMCON
	mov	#0x55,W0	;Unlock sequence - interrupts need to be off
	mov	W0,NVMKEY
	mov	#0xAA,W0
	mov	W0,NVMKEY
	bset NVMCON,#WR
	nop				;Required
	nop
1:	btsc NVMCON,#WR	;Wait for write end
	bra 1b
	
	return
	
;***************************************************************	
_WriteLatch: ;W0=TBLPAG,W1=Wn,W2=WordHi,W3=WordLo - no return values
	mov	W0,TBLPAG	
	tblwtl W3,[W1]
	tblwth W2,[W1]
	
	return
	
;***************************************************************	
_ReadLatch: ;W0=TBLPAG,W1=Wn - data in W1:W0
	mov	W0,TBLPAG	
	tblrdl [W1],W0
	tblrdh [W1],W1
	
	return


;***************************************************************

#define PM_ROW_SIZE 32
#define CM_ROW_SIZE 7
#define CONFIG_WORD_SIZE 1

#define PM_ROW_ERASE 		0x4041
#define PM_ROW_WRITE 		0x4001
#define EE_ROW_ERASE 		0x4045
#define EE_ROW_WRITE 		0x4005
#define CONFIG_WORD_WRITE	0X4008

char Buffer[PM_ROW_SIZE*3 + 1];
	int    Size;
  	uReg32 SourceAddr;
	UWord32 Opcode;

	SourceAddr.Val[0] = 0;
	SourceAddr.Val[1] = 0;
	SourceAddr.Val[2] = 0;
	for(Size = 0; Size < PM_ROW_SIZE*3; Size++)
	{
		Buffer[Size] = Size;
	}
	SourceAddr.Word.HW = 0x0000;
	SourceAddr.Word.LW = 0x0000;
	LoadAddr(SourceAddr.Word.HW,SourceAddr.Word.LW);
	
	WriteMem(PM_ROW_ERASE);				/*Erase  page  */
	WritePM(Buffer, SourceAddr);		/*program page */