else
    {
      Nf_CS_ODD();          
      Nf_wait_busy_odd();
      Nf_write_open_C_area_odd(nf_current_physical_sector_addr_odd,0x00);   /* open spare data area */
      nf_update_spare_data();                                               /* update spare data    */
      Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);                            /* send program command */ 
      ((Byte*)&nf_current_physical_sector_addr_odd)[3]++;
    }
    state = ~state;
  } 
}



/*F**************************************************************************
* NAME:     nf_copy_block_head
*----------------------------------------------------------------------------
* PARAMS:   block : physical block number
*           nb_sector : number of sector to be copied
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  This function copy the first part of a block that is not modified
*           during a write operation
*
*****************************************************************************
* NOTE: Uint32 address is global     
*       This function uses the Samsung NF specific command: Copy-Back Program    
*
*****************************************************************************/
void nf_copy_block_head(void)
{
Byte j;
bit state = 0;
Uint32 address2;

  /* address of the source physical block */
  gl_address = (Uint32)(nf_block_to_be_deleted_even) << 5;
  address2 = (Uint32)(nf_block_to_be_deleted_odd) << 5;

  for (j = (((Byte*)&gl_ptr_mem)[3] & 0x3F); j != 0; j--)
  { 
    if (!state)
    {
      Nf_CS_EVEN();
      Nf_wait_busy_even();
      if (NF_COPY_BACK_BIT)
      {
        Nf_send_command_even(NF_READ_A_AREA_CMD);
        Nf_send_cl_address_even(gl_address, 0x00);
        Nf_wait_busy_even();
        Nf_send_command_even (NF_COPY_BACK_TO_PAGE);
        Nf_send_cl_address_even(nf_current_physical_sector_addr_even, 0x00);
        Nf_send_command_even (NF_PAGE_PROGRAM_CMD);
      }
      else
      {
        Nf_send_command_even(NF_READ_A_AREA_CMD);
        Nf_send_cl_address_even(gl_address, 0x00);
        Nf_wait_busy_even();
        nf_upload_buffer();
        Nf_write_open_A_area_even(nf_current_physical_sector_addr_even, 0x00);
        nf_download_buffer();
        Nf_send_command_even (NF_PAGE_PROGRAM_CMD);
        Nf_wait_busy_even();
        Nf_send_command_even(NF_READ_B_AREA_CMD);
        Nf_send_cl_address_even(gl_address, 0x00);
        Nf_wait_busy_even();
        nf_upload_buffer();
        Nf_write_open_B_area_even(nf_current_physical_sector_addr_even, 0x00);
        nf_download_buffer();
        nf_update_spare_data();
        Nf_send_command_even (NF_PAGE_PROGRAM_CMD);
      }

      /* increase counter */
      ((Byte*)&nf_current_physical_sector_addr_even)[3]++;
      ((Byte*)&gl_address)[3]++;

    }
    else
    {
      Nf_CS_ODD();
      Nf_wait_busy_odd();
  
      if (NF_COPY_BACK_BIT)
      {
        Nf_send_command_odd(NF_READ_A_AREA_CMD);
        Nf_send_cl_address_odd(address2, 0x00);
        Nf_wait_busy_odd();
        Nf_send_command_odd (NF_COPY_BACK_TO_PAGE);
        Nf_send_cl_address_odd(nf_current_physical_sector_addr_odd, 0x00);
        Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);
      }
      else
      {
        Nf_send_command_odd(NF_READ_A_AREA_CMD);
        Nf_send_cl_address_odd(address2, 0x00);
        Nf_wait_busy_odd();
        nf_upload_buffer();
        Nf_write_open_A_area_odd(nf_current_physical_sector_addr_odd, 0x00);
        nf_download_buffer();
        Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);
        
        Nf_wait_busy_odd();
        Nf_send_command_odd(NF_READ_B_AREA_CMD);
        Nf_send_cl_address_odd(address2, 0x00);
        Nf_wait_busy_odd();
        nf_upload_buffer();
        Nf_write_open_B_area_odd(nf_current_physical_sector_addr_odd, 0x00);
        nf_download_buffer();
        nf_update_spare_data();
        Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);
      }
      ((Byte*)&nf_current_physical_sector_addr_odd)[3]++;
      ((Byte*)&address2)[3]++;
    }
    state = ~state;
  }       /* end for */
}


/*F**************************************************************************
* NAME:     nf_copy_block_tail
*----------------------------------------------------------------------------
* PARAMS:   block : physical block number
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  This function copy the last part of a block that is not modified
*           during a write operation
*
*****************************************************************************
* NOTE:     Uint32 address is global
*
*****************************************************************************/
void nf_copy_block_tail(void)
{
Byte j;
bit state;
Uint32 address2;

  /* Address of the source block */
  gl_address = ((Uint32)(nf_block_to_be_deleted_even) << 5) +  ((gl_ptr_mem & 0x3F) >> 1) + (gl_ptr_mem & 0x01);
  address2 = ((Uint32)(nf_block_to_be_deleted_odd) << 5) +  ((gl_ptr_mem & 0x3F) >> 1);

  state = ((Byte*)&gl_ptr_mem)[3] & 0x01;

  for (j = (((Byte*)&gl_ptr_mem)[3] & 0x3F); j < 64; j++)
  { 
    if (!state)
    {
      Nf_CS_EVEN();
      Nf_wait_busy_even();
      if (NF_COPY_BACK_BIT)
      {
        Nf_send_command_even(NF_READ_A_AREA_CMD);
        Nf_send_cl_address_even(gl_address, 0x00);
        Nf_wait_busy_even();
        
        Nf_send_command_even (NF_COPY_BACK_TO_PAGE);
        Nf_send_cl_address_even(nf_current_physical_sector_addr_even, 0x00);
        Nf_send_command_even (NF_PAGE_PROGRAM_CMD);
      }
      else
      {
        Nf_read_open_A_area_even(gl_address, 0x00);
        nf_upload_buffer();
        Nf_write_open_A_area_even(nf_current_physical_sector_addr_even, 0x00);
        nf_download_buffer();
        Nf_send_command_even (NF_PAGE_PROGRAM_CMD);
        Nf_wait_busy_even();
        Nf_send_command_even(NF_READ_B_AREA_CMD);
        Nf_wait_busy_even();
        Nf_read_open_B_area_even(gl_address, 0x00);
        nf_upload_buffer();
        Nf_write_open_B_area_even(nf_current_physical_sector_addr_even, 0x00);
        nf_download_buffer();
        nf_update_spare_data();
        Nf_send_command_even (NF_PAGE_PROGRAM_CMD);
      }

      /* increase counter */
      ((Byte*)&nf_current_physical_sector_addr_even)[3]++;
      ((Byte*)&gl_address)[3]++;
      state = 1;
    }
    else
    {
      Nf_CS_ODD();
      Nf_wait_busy_odd();
      
      if (NF_COPY_BACK_BIT)
      {
        Nf_send_command_odd(NF_READ_A_AREA_CMD);
        Nf_send_cl_address_odd(address2, 0x00);
        Nf_wait_busy_odd();
        Nf_send_command_odd (NF_COPY_BACK_TO_PAGE);
        Nf_send_cl_address_odd(nf_current_physical_sector_addr_odd, 0x00);
        Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);
      }
      else
      {
        Nf_read_open_A_area_odd(address2, 0x00);
        nf_upload_buffer();
        Nf_write_open_A_area_odd(nf_current_physical_sector_addr_odd, 0x00);
        nf_download_buffer();
        Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);
        Nf_wait_busy_odd();
        Nf_read_open_B_area_odd(address2, 0x00);
        nf_upload_buffer();
        Nf_write_open_B_area_odd(nf_current_physical_sector_addr_odd, 0x00);
        nf_download_buffer();
        nf_update_spare_data();
        Nf_send_command_odd (NF_PAGE_PROGRAM_CMD);
      }
      ((Byte*)&nf_current_physical_sector_addr_odd)[3]++;
      ((Byte*)&address2)[3]++;
        
      state = 0;
    }
  }
}


/*F**************************************************************************
* NAME:     nf_reassign_block
*----------------------------------------------------------------------------
* PARAMS:   block : reassign the physical block
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  This function reassign the block value in LUT (copy of LUT)
*           
*
*****************************************************************************
* NOTE:     
*           
*
*****************************************************************************/
void nf_reassign_block(void)
{
Byte    dummy;
Byte    j;
Uint16  k;
xdata Uint16  start;
xdata Uint16  block_start;                     
xdata Uint32  address2;                           /* LUT Source address */

  if (lut_index[nf_zone] >= 3)                    /* the LUT can be copied 4 times in a block */
  {
    if ((buf_free[nf_gl_buf_free_idx].even & 0x7FFF) == nf_look_up_table_block)
    {
      nf_gl_buf_free_idx++;
      if (nf_gl_buf_free_idx >= nf_spare_block)
      {
        nf_gl_buf_free_idx = 0;
      }      
    }

    /* Source address */
    address2 = ((Uint32)(nf_look_up_table_block)<<5) + 24;               /* 24 = index of last copied LUT */

    nf_look_up_table_block =  buf_free[nf_gl_buf_free_idx].even & 0x7FFF;
    
    nf_gl_buf_free_idx++;
    if (nf_gl_buf_free_idx >= nf_spare_block)
    {
      nf_gl_buf_free_idx = 0;
    }      

    /* Target address : recopy the last 4Kb */
    gl_address = ((Uint32)(nf_look_up_table_block) << 5);

    lut_index[nf_zone] = 0;
  }
  else
  {
    /* Source address */
    address2 = ((Uint32)(nf_look_up_table_block)<<5) + ((Uint32)(lut_index[nf_zone])<<3);

    lut_index[nf_zone]++;

    /* Target address */
    gl_address = address2 + 8; /* 8 pages = size of a copy of the lut */
  }

  j = 0;
  k = 0;
  start = 0;
  block_start = nf_block_min;

  Nf_CS_EVEN();

  do
  {
    /* upload the buffer */
    Nf_wait_busy_even();
    Nf_read_open_A_area_even(address2, 0x00);
    nf_upload_buffer();
    /* update the buffer */    
    while ((k <= nf_gl_buf_idx_max) && (start <= block_start) && ((start + 64) > block_start))
    {
      j = 4 * (block_start & 0x3F);
      gl_buffer[j   ] = buf[k].even.b[0];
      gl_buffer[j+ 1] = buf[k].even.b[1];
      gl_buffer[j+ 2] = buf[k].odd.b[0];
      gl_buffer[j+ 3] = buf[k].odd.b[1];
      k++;
      block_start++;
    }
    Nf_write_open_A_area_even(gl_address, 0x00);
    nf_download_buffer();
    Nf_send_command_even(NF_PAGE_PROGRAM_CMD);

    start += 64;
    Nf_wait_busy_even();
    Nf_read_open_B_area_even(address2, 0x00);
    nf_upload_buffer();

    while ((k <= nf_gl_buf_idx_max) && (start <= block_start) && ((start + 64) > block_start))
    {
      j = 4 * (block_start & 0x3F);
      gl_buffer[j    ] = buf[k].even.b[0];
      gl_buffer[j + 1] = buf[k].even.b[1];
      gl_buffer[j + 2] = buf[k].odd.b[0];
      gl_buffer[j + 3] = buf[k].odd.b[1];
      k++;
      block_start++;
    }   
 
    if (start >= 960)   /* This part update the free physical block table */
    {                   /* 960 = first logical block in part B of the last page of the Lut */
      dummy = 160;      /* 160 = offset for free blocks in part B of the last page of the Lut */
      for (j = 0; j <= 23; j++)
      {           
        gl_buffer[dummy    ] = buf_free[j].even>>8;
        gl_buffer[dummy + 1] = buf_free[j].even; 
        gl_buffer[dummy + 2] = buf_free[j].odd>>8;
        gl_buffer[dummy + 3] = buf_free[j].odd; 
        dummy += 4;
      }
    }

    Nf_write_open_B_area_even(gl_address, 0x00);
    nf_download_buffer();    /* download the buffer */

    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xE8);