/* START CONFIDENTIAL */

/*******************************************************************/
/*  DEBUT DU MODULE PC-URNE.C                                      */
/*******************************************************************/
   
#include "cfgscrut.h"

CFGSCRUT  cfgS[NMX_SCRUTIN_T+1] = { {0, 0, 0},
                                {VM_EUROPE,   NMXV_EUROPE,   NMXB_EUROPE},
                                {VM_CHAMBRE,  NMXV_CHAMBRE,  NMXB_CHAMBRE},
                                {VM_SENAT,    NMXV_SENAT,    NMXB_SENAT},
                                {VM_REGION,   NMXV_REGION,   NMXB_REGION},
                                {VM_PROVINCE, NMXV_PROVINCE, NMXB_PROVINCE},
                                {VM_COMMUNE,  NMXV_COMMUNE,  NMXB_COMMUNE},
                                {VM_CONSEIL_FLAMANT, NMXV_CONSEIL_FLAMANT, 
				 NMXB_CONSEIL_FLAMANT},
				{VM_DISTRICT, NMXV_DISTRICT, NMXB_DISTRICT},
				{VM_CPAS,     NMXV_CPAS,     NMXB_CPAS}
				};

#include <dos.h>
#include <io.h>
#include <conio.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>

#include "defs.h"
#include "..\LibUrne\LibUrne.h"
#include "pcurne.h"

/*******************************/
#define  _Blanc_Non_Exp  0
#define  _Blanc_Exp      1
#define  _Vote           2
#define  _Pas_De_Vote    3
/*******************************/

int  TYPE_SCRUTIN[5];
int  BK_PC = 0;
int  SW_EURO = 0; /* not used */
int  SW_STR  = 0;  /*  euroland people or not */
/*******************************/

char MULTI_ELEC; 

struct scrutin_t
{
  int  Nombre_Listes;
  int Votes_Bl_Exp;
  int Votes_Bl_Non_Exp;
  struct liste_t *ptlist;
}scrutin[5];

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

int Nb_Liste,Nb_Candidat, iMAXDISK;
char *Buffer_Par,Car,Type_Multi;

char Table_VM[100];  /* Array of the multiple votes */
                     /* Table_VM[0] = Head of list          */
                     /* Table_[1..n]= other candidates        */

struct liste_t *ps, *adrl;

/****************************************************************************/
/* Vote counters */
extern int  *piNOMBRE_VOTES1, *piNOMBRE_VOTES2, *piNOMBRE_VOTES3;
extern int  *piNOMBRE_NATIO_VOTES1, *piNOMBRE_NATIO_VOTES2, *piNOMBRE_NATIO_VOTES3;
extern int  *piNOMBRE_STR_VOTES1, *piNOMBRE_STR_VOTES2, *piNOMBRE_STR_VOTES3;

/*****************************************************************************/
extern char fullPassword[11];
extern szMessage *pszMessage_Point;
extern char JETON_ETENDU[_JETON_ETENDU_MAX_BYTE+1];
extern char GCOLOR;
/******************************************************************************/
/*
   <FUNCTION>
		<NAME>Initialise_Variables</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Analyze the table coming from the control PC, intializes the tables containing
		the polls and the extended token. Determine the number of floppy by polling 
		station
		</DESCRIPTION>
        <PARAMETER>
			<NAME>Buffer</NAME>
			<TYPE>char *</TYPE>
			<IO>IN</IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE></TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/
void Initialise_Variables(char *Buffer)
{

  char strtmp[4];
  char bidon[16];
  int i, j, k, Type;

/****   Initialization of the multiple votes  ********/
  
  GLOBAL_EURO = 0;
  GLOBAL_STR  = 0;


  C_VOTE_MAX_BYTE = 0;
  _LECT_CHAINE(JETON_ETENDU,Buffer,k,_JETON_ETENDU_MAX_BYTE);
  _LECT_CHAINE(bidon,Buffer,k,_JETON_ETENDU_MAX_BYTE);
  _LECT_NOMBRE(NOMBRE_SCRUTIN,strtmp,Buffer,k,1);


  
  for (i = 0; i < NOMBRE_SCRUTIN; i++)
    { 
      _LECT_NOMBRE(Type,strtmp,Buffer,k,1);
      TYPE_SCRUTIN[i] = Type;
      if (cfgS[TYPE_SCRUTIN[i]].swVM == 1)
      {
	  C_VOTE_MAX_BYTE += (cfgS[TYPE_SCRUTIN[i]].nmxB +2);
      }
      
      strncpy(strtmp,JETON_ETENDU,3);       
      strtmp[3] = 0x00;

      if ((SW_STR == 0) && (NOMBRE_SCRUTIN > 1) && (TYPE_SCRUTIN[i] == 6))
      {
			SW_STR = 1;
      }

      _LECT_NOMBRE(Nb_Liste,strtmp, Buffer,k,2);
      scrutin[i].Nombre_Listes    = Nb_Liste;
      scrutin[i].Votes_Bl_Exp     = 0;
      scrutin[i].Votes_Bl_Non_Exp = 0;
      
      ps = (struct liste_t *) malloc(sizeof(struct liste_t)* scrutin[i].Nombre_Listes);
	  /* << 9.01b*/
	  if(ps == NULL)
	  {
		  Lcd_Affiche(0,0, pszMessage_Point[121]);
		  Lcd_Affiche(1,0, pszMessage_Point[7]);
		  Boucle_Erreur();
	  }
	  /* >> */
      scrutin[i].ptlist = ps;
      for(j=0;j < scrutin[i].Nombre_Listes;j++)
      {
		   _LECT_NOMBRE(Nb_Candidat,strtmp,Buffer,k,3);
		   ps->Nombre_Effectifs = Nb_Candidat;
		   _LECT_NOMBRE(Nb_Candidat,strtmp,Buffer,k,2);
		   ps->Nombre_Suppleants = Nb_Candidat;
		   ps->Votes_Effectifs   = 0;
		   ps->Votes_Suppleants  = 0;
		   ps->Votes_Tete_Liste  = 0;
		   ps->Votes_Liste       = 0;
		   for(k = 0; k < 90;k++)
		   ps->Votes_Candidats[k] = 0; 
		   ps++;
     }
    }

 if(i > 1)
 {
	MULTI_ELEC = 'P'; /*  Several polls  */
 }
 else
 {
	MULTI_ELEC = 'N';
 }

 if(SW_STR == 1)
 {
     GLOBAL_STR = 1;
 }

 switch(i)
 {
    /*<< 9.01c*/
	case 1 : iMAXDISK = 3;
	    break;
	/*>>*/
	case 2 :
	case 3 :
	    iMAXDISK = 3 + DISKSUP;
	    break;
 }
 
} /* Initialise_Variables */

/**************************************************************************/
/*
   <FUNCTION>
		<NAME>Lit_Fichier_ARR</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Reading of the file coming from the control PC to get the
		extended token
		</DESCRIPTION>
        <PARAMETER>
			<NAME>Nom_Fichier</NAME>
			<TYPE>char *</TYPE>
			<IO>IN</IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE>int</TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/
int Lit_Fichier_ARR(char *Nom_Fichier)
{
   char Buffer[20];
   int Erreur, nbcar,k;
   FILE *Fichier_PCC;

   Fichier_PCC = fopen(Nom_Fichier, "rt");
   if (Fichier_PCC == NULL)
     { 
       Erreur = _W_FICHIER_PAS_TROUVE;
       return(Erreur);
     }
   
   nbcar = fread(Buffer, 1, 15, Fichier_PCC);
   
   if (nbcar != 15)
     { 
       Erreur = _W_LECTURE;
       fclose(Fichier_PCC);
       return(Erreur);
     }
   Buffer[15]= 0x00;
   strcpy(JETON_ETENDU,Buffer);
   fclose(Fichier_PCC);
   return(_PAS_ERREUR);
} /* Lit_Fichier_ARR */
/**************************************************************************/
/*
   <FUNCTION>
		<NAME>Lit_Fichier_PCC</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Reading of the file coming from the control PC. Execute Initialise_Variables
		function
		</DESCRIPTION>
        <PARAMETER>
			<NAME>Nom_Fichier</NAME>
			<TYPE>char *</TYPE>
			<IO>IN</IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE>int</TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/
int Lit_Fichier_PCC(char *Nom_Fichier)
{
   char *Buffer,*Buffer1,*Buffer2;
   int  Taille_Fichier, Numero_Fichier, Erreur, nbcar;
   FILE *Fichier_PCC;

   Fichier_PCC = fopen(Nom_Fichier, "rt");
   if (Fichier_PCC == NULL)
     { 
       Erreur = _W_FICHIER_PAS_TROUVE;
       return(Erreur);
     }
   
   Numero_Fichier = fileno(Fichier_PCC);
   Taille_Fichier = filelength(Numero_Fichier);
   if (Taille_Fichier == -1L)
     { 
       Erreur = _W_LECTURE;
       fclose(Fichier_PCC);
       return(Erreur);
     }
   
   Buffer1= malloc(Taille_Fichier);
   if (Buffer1 == NULL)
     { 
       Erreur = _W_MEMOIRE;
       fclose(Fichier_PCC);
       return(Erreur);
     }
   Buffer_Par = Buffer1;
   
   nbcar = fread(Buffer1, 1, Taille_Fichier, Fichier_PCC);
   if(nbcar == 0)
   {
	   Erreur = _W_LECTURE;
	   /* << 9.01b */
	   free(Buffer1);
	   /* >> */
       fclose(Fichier_PCC);
       return(Erreur);
   }
   
   Buffer = malloc(Taille_Fichier);
   if (Buffer == NULL)
     { 
       /* << 9.01b */
	   free(Buffer1);
       fclose(Fichier_PCC);
	   /* >> */
	   Erreur = _W_MEMOIRE;
       return(Erreur);
     }
  
   Buffer2 = Buffer;                        
   for(;*Buffer1;Buffer1++)
        if(*Buffer1 > 0x0D)
                  *Buffer2++ = *Buffer1;
   
   fclose(Fichier_PCC);
   Initialise_Date(Buffer);
   Initialise_Variables(Buffer);
   free(Buffer);
   return(_PAS_ERREUR);
} /* Lit_Fichier_PCC */

/**************************************************************************/
/*
   <FUNCTION>
		<NAME>Additione_Vote_Multiple</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Add the multiple votes results according the electoral list
		</DESCRIPTION>
        <PARAMETER>
			<NAME>Scrutin, Liste,Vote</NAME>
			<TYPE>int , int, int</TYPE>
			<IO>IN,IN,IN</IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE></TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/

void Additione_Vote_Multiple(int Scrutin, int Liste,int Vote)
{
  int j,Eff,i,Var_Int, SW;
  int nVeff = 0, nVsup = 0;

  if(Vote != _Pas_De_Vote)
  {
	  if(Vote == _Blanc_Non_Exp)
		scrutin[Scrutin].Votes_Bl_Non_Exp++;
	  else if(Vote == _Blanc_Exp)
		   scrutin[Scrutin].Votes_Bl_Exp++;
	  else
	  {
		Liste--;
		ps = scrutin[Scrutin].ptlist;
		for(j = 0;j < Liste;j++)ps++;
		ps->Votes_Liste++;
		SW = 0;
	           
		for(i = 1 ; ((i < 90) && (i <= ps->Nombre_Effectifs)); i++)
		{
		   if(Table_VM[i] == '1')
		   {
			Var_Int = i - 1;
			ps->Votes_Candidats[Var_Int]++;
			SW = 1; nVeff++;
		   }
		}

		for(i = (1 + ps->Nombre_Effectifs);
			((i<90) && (i<=(ps->Nombre_Effectifs + ps->Nombre_Suppleants)));i++)
		{
				 if(Table_VM[i] == '1')
				  {
					Var_Int = i - 1;
					ps->Votes_Candidats[Var_Int]++;
					SW = 1; nVsup++;
				  }
		}

		if((Table_VM[0] == '1') && (SW == 0))  
			ps->Votes_Tete_Liste++;  
		if ((nVeff>0) && (nVsup==0)) ps->Votes_Effectifs++;  
	           
		if ((nVsup>0) && (nVeff==0)) ps->Votes_Suppleants++; 
	    
	  }
  }

} /*  */
/**************************************************************************/
/*
   <FUNCTION>
		<NAME>Ecrit_Table_PCC</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Write the results of the election in the file Table.urn
		</DESCRIPTION>
        <PARAMETER>
			<NAME>Nom_Fichier</NAME>
			<TYPE>char *</TYPE>
			<IO>IN</IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE>int</TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/
int Ecrit_Table_PCC(char *Nom_Fichier)
{
   int Erreur,j, i, k,Tot1,Tot2;
   long TotVote;
   int liste;
   size_t nbcar;
   char strtmp[12],CTotal[5];
   FILE *Fichier,*Fichier2;
   
   TotVote = 0;

   Check_Vote_Counters();

   Fichier = fopen(Nom_Fichier, "wt");
   if (Fichier == NULL)
     {
       Erreur = _W_CREATION_FICHIER;
       return(Erreur);
     }
   /*writing of the extended token*/
   fwrite(JETON_ETENDU, 1, _JETON_ETENDU_MAX_BYTE, Fichier);
   fprintf(Fichier,"\n");
   for (i = 0; i < NOMBRE_SCRUTIN; i++)
   {
        /*writing the results of the votes by poll and by list*/
		ps = scrutin[i].ptlist;
        for(j = 0;j < scrutin[i].Nombre_Listes;j++,ps++) 
        {
           TotVote += ps->Votes_Liste;
           sprintf(strtmp, "%4d", ps->Votes_Liste);
           nbcar = fwrite(strtmp, 1, 4, Fichier);
           
           if (nbcar != 4)
             {
               Erreur = _W_ECRITURE;
               fclose(Fichier);
               return(Erreur);
             }
           
           TotVote += ps->Votes_Tete_Liste;
           sprintf(strtmp, "%4d",ps->Votes_Tete_Liste);
           nbcar = fwrite(strtmp, 1, 4, Fichier);
           
           if (nbcar != 4)
             {
               Erreur = _W_ECRITURE;
               fclose(Fichier);
               return(Erreur);
             }
	   TotVote += ps->Votes_Effectifs;
           sprintf(strtmp, "%4d",ps->Votes_Effectifs);
           nbcar = fwrite(strtmp, 1, 4, Fichier);
           
           if (nbcar != 4)
             {
               Erreur = _W_ECRITURE;
               fclose(Fichier);
               return(Erreur);
             }

	   for(k = 0;k < (ps->Nombre_Effectifs);k++)
             {
               TotVote += ps->Votes_Candidats[k];
               sprintf(strtmp, "%4d",ps->Votes_Candidats[k]); 
               nbcar = fwrite(strtmp, 1, 4, Fichier);
               
               if (nbcar != 4)
                  {
                    Erreur = _W_ECRITURE;
                    fclose(Fichier);
                    return(Erreur);
                  }
              }               
        }     

	   sprintf(strtmp, "--------");
           nbcar = fwrite(strtmp, 1, 8, Fichier);
           
           if (nbcar != 8)
             { 
               Erreur = _W_ECRITURE;
               fclose(Fichier);
               return(Erreur);
             }
           
           sprintf(strtmp, "%4d",scrutin[i].Votes_Bl_Exp);
           
           nbcar = fwrite(strtmp, 1, 4, Fichier);
           if (nbcar != 4)
            {
             Erreur = _W_ECRITURE;
             fclose(Fichier);
             return(Erreur);
            }
           
           sprintf(strtmp, "%4d",scrutin[i].Votes_Bl_Non_Exp);
           nbcar = fwrite(strtmp, 1, 4, Fichier);
           
           if (nbcar != 4)
             {
	       Erreur = _W_ECRITURE;
               fclose(Fichier);
               return(Erreur);
             }
   }
   
   /*writing the vote counters*/
   if(MULTI_ELEC == 'N')
   {
		sprintf(strtmp,"%4d", *piNOMBRE_VOTES1);
   }
   else
   {
		sprintf(strtmp,"%4d", *piNOMBRE_NATIO_VOTES1);
   }

   nbcar = fwrite(strtmp, 1, 4, Fichier);
   if (nbcar != 4)
     {
       Erreur = _W_ECRITURE;
       fclose(Fichier);
       return(Erreur);
     }
   
   sprintf(strtmp,"%4d", *piNOMBRE_STR_VOTES1);
   nbcar = fwrite(strtmp, 1, 4, Fichier);
   if (nbcar != 4)
     {
       Erreur = _W_ECRITURE;
       fclose(Fichier);
       return(Erreur);
     }
   
   sprintf(strtmp,"%4d", *piNOMBRE_VOTES1);
   nbcar = fwrite(strtmp, 1, 4, Fichier);
   if (nbcar != 4)
     {
       Erreur = _W_ECRITURE;
       fclose(Fichier);
       return(Erreur);
     }
   
   sprintf(strtmp,"%8ld", TotVote); /* Total of the votes of preferences */
   nbcar = fwrite(strtmp, 1, 8, Fichier);
   
   if (nbcar != 8)
     {
       Erreur = _W_ECRITURE;
       fclose(Fichier);
       return(Erreur);
     }
    sprintf(strtmp, " ");
    nbcar = fwrite(strtmp, 1, 1, Fichier);
           
   if (nbcar != 1)
     { 
       Erreur = _W_ECRITURE;
       fclose(Fichier);
       return(Erreur);
     }

   Tot1 = atoi(Minicodage);
   CTotal[0] = fullPassword[0];
   CTotal[1] = fullPassword[2];
   CTotal[2] = fullPassword[4];
   CTotal[3] = fullPassword[6];
   CTotal[4] = 0x00;
   Tot2 = atoi(CTotal);

   sprintf(strtmp,"%5d", Tot1 + Tot2); 
   nbcar = fwrite(strtmp, 1, 5, Fichier);

   if (nbcar != 5)
     {
       Erreur = _W_ECRITURE;
       fclose(Fichier);
       return(Erreur);
     }
   fclose(Fichier);
   return(_PAS_ERREUR);
}
 /* Ecrit_Table_PCC */
/****************************************************************************/
/*
   <FUNCTION>
		<NAME>Transfert_Table_PCC</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Recover the contents of the recorded votes and retranscribes them into
		binary. Execute Ecrit_Table_PCC function
		</DESCRIPTION>
        <PARAMETER>
			<NAME>Nom_Fichier</NAME>
			<TYPE>char *</TYPE>
			<IO>IN</IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE></TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/
void Transfert_Table_PCC(char *Nom_Fichier)
{
  unsigned int Position, Parite;
  int Erreur, Numero, Liste, Eff, Sup,Param;
  char Carte_Tmp[76],Nul_StrL[3],Nul_StrE[3],Nul_StrS[3], cElec_Type;
  FILE *Fichier;
  int  i,Compt,CI,j,Var_Int;
  /*<< 9.01c*/
  unsigned int iVoteSize; 
  /*>>*/
  boolean bIndic;
  char strtmp[21],strtmp3[65], /*<< 9.01c*/szPassword[16]/*>>*/;

  Nul_StrL[2] = 0x00;
  Nul_StrE[2] = 0x00;
  Nul_StrS[2] = 0x00;
  
  *piNOMBRE_VOTES1 = 0;
  *piNOMBRE_VOTES2 = 0;
  *piNOMBRE_VOTES3 = 0;

/* << 9.01b */
  Lcd_Affiche(0,0, pszMessage_Point[12]);
/* 9.01b >> */

  for (Position = 0; Position < _E_NB_MAX_VOTE; Position++)
  { 
    /* Leds */
	GCOLOR = _ON_RED;
	Light_LED(GCOLOR);

	Car = Est_Valide_E_Vote(Position);
	if(SUPPORT == 'N')
		break;
    if (Car )
    {
	   /*<< 9.01c*/
       /*Recupere_E_Vote(Position,Carte_Tmp,C_VOTE_MAX_BYTE + _C_CRC_MAX_BYTE +_C_TEST_MAX_BYTE);*/
       iVoteSize = C_VOTE_MAX_BYTE + _C_CRC_MAX_BYTE + _C_TEST_MAX_BYTE;
       Recupere_E_Vote(Position,Carte_Tmp,iVoteSize);
	   
	   Generate_Password(szPassword,Position,true);
	   Encrypt_Decrypt(Carte_Tmp,szPassword,iVoteSize); 
	   /*>>*/
       strncpy(strtmp3,&Carte_Tmp[_C_CRC_MAX_BYTE + _C_TEST_MAX_BYTE ],C_VOTE_MAX_BYTE);
       strtmp3[C_VOTE_MAX_BYTE]= 0x00;

       Calcul_Crc(Carte_Tmp,_C_CRC_MAX_BYTE);
       Recupere_Crc(Carte_Tmp,0);
       if (strcmp(Crc_Calcul,Crc_Recup)!= 0)
       {
			Lcd_Affiche(0,0,pszMessage_Point[27]);
			Lcd_Affiche(1,0,pszMessage_Point[7]);
			Boucle_Erreur();
       }

       *piNOMBRE_VOTES1 += 1;
       *piNOMBRE_VOTES2 += 1;
       *piNOMBRE_VOTES3 += 1;
	   
	   cElec_Type = Carte_Tmp[_C_CRC_MAX_BYTE];
       strcpy(Carte_Tmp,strtmp3);
       for (Compt = 0, i = 0; i < NOMBRE_SCRUTIN; i++)
	   {

			strncpy(Nul_StrL,&Carte_Tmp[Compt],2);
			Nul_StrL[2] = 0x00;
			Liste = atoi(Nul_StrL);

			if(Liste == 0)
			{
				if(cElec_Type == 'S')
				{
					if((TYPE_SCRUTIN[i] == 6) || (TYPE_SCRUTIN[i] == 8))
						Param = _Blanc_Non_Exp;
					else 
						Param = _Pas_De_Vote;
				}
				else
					Param = _Blanc_Non_Exp;
			}
			else if(Liste == 99)
				Param = _Blanc_Exp;
			else if(Liste == 98)
				Param = _Pas_De_Vote;
			else
				Param = _Vote;

			Compt +=2;
			for(CI = 0; CI < cfgS[TYPE_SCRUTIN[i]].nmxV; Compt++)
			{
				  switch(Carte_Tmp[Compt])
				   {
                    
					case '1' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   break;
					case '2' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   break;
					case '3' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   break;
					case '4' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   break;
					case '5' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   break;
					case '6' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   break;
					case '7' : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   break;
					case '8' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   break;
					case '9' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   break;
					case 'A' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   break;
					case 'B' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   break;
					case 'C' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   break;
					case 'D' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '1';
							   break;
					case 'E' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '0';
							   break;
					case 'F' : Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   Table_VM[CI++] = '1';
							   break;
					default  : Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
							   Table_VM[CI++] = '0';
				   }
				 }
			   Additione_Vote_Multiple(i, Liste,Param);

			}
		}
   }
   
   if(SUPPORT != 'N')
   {
		while (Ecrit_Table_PCC(Nom_Fichier) != _PAS_ERREUR)
		{ 
			Lcd_Affiche(0,0, pszMessage_Point[36]);
			Lcd_Affiche(1,0, pszMessage_Point[14]);
			Getch(COLOR);
			Lcd_Affiche(0,0, "");
			Lcd_Affiche(1,0,"");
		}
   }
   GCOLOR = _ON_GREEN;
   Light_LED(GCOLOR); 
} /* Tansfert_Table_PCC */
/***************************************************************************/
/*
   <FUNCTION>
		<NAME>Verifie_E_Vote</NAME>
        <TYPE>LOCAL</TYPE>
		<DESCRIPTION>
		Check if electoral list is valid according the poll
		</DESCRIPTION>
        <PARAMETER>
			<NAME></NAME>
			<TYPE></TYPE>
			<IO></IO>
			<DESCRIPTION></DESCRIPTION>
		</PARAMETER>
		<RETURN>
			<TYPE>int</TYPE>
			<DESCRIPTION></DESCRIPTION>
		</RETURN>
   </FUNCTION>
*/
int Verifie_E_Vote()
{
  int E_Position, E_scrutin, E_list;
  char C_list[3];

  for( E_scrutin = 0, E_Position = (_C_CRC_MAX_BYTE +_C_TEST_MAX_BYTE); E_scrutin < NOMBRE_SCRUTIN;E_scrutin++) 
  {
     strncpy(C_list,&szVoteContent[E_Position] ,2);
     C_list[2] = 0x00;
     E_list = atoi(C_list);

     if ((E_list < 98) && ( E_list >  scrutin[E_scrutin].Nombre_Listes))
         return(1);
     E_Position += cfgS[TYPE_SCRUTIN[E_scrutin]].nmxB + 2;
  }
 return(0);
} 
/****************************************************************************/

