i release my private librairy "qbytes" (quantique bytes)
this is a mathematic tool where all bits of a double word have 3 states :
one , zero and unknow
i implemented the addition , multiplication (with an integer), a new concept
"fusion" (equivalent to = ) , and all basic booleean functions (binary
version of xor, or, no , and)
there are some utilities like error detection, error depth etc ...

i used this lib for coding fuckmd5.cpp

if you want to use multithreading the code need modification

i think this tool is good for easy recomputation and error detection in the
case of a cryptographic attack

quantique.h : structure definition
qbyte.h : class definition
qbyte.cpp : all the functions

download link :
http://81.57.125.106/~slythers/qbyte%20and%20md5%20recomputation.rar

the quantique.h
-----------------------------------------------------------------------------
/*
(c) b4d coder
Malloc(0) Wicked Attitude

Copyright (c) 2006, overdose : slythers@gmail.com
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
    * Neither the name of the Malloc(0) Wicked Attitude nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/

#define PARAM_LIST_SIZE_BASE (sizeof(unsigned int)+sizeof(unsigned
char)+sizeof(char)+sizeof(bool))
#define MAX_ADD (255)

struct quantique
{
 unsigned int value;
 unsigned int know;
};

struct quantparam{
 unsigned int size;
 char type;
 unsigned char nb;
 bool error;
 struct quantique *wesh[2];
};


the qbyte.h
-----------------------------------------------------------------------------
/*
 B4d coder (c)
 Quantique Bytes librairy (cryptographic attack tool)
 coded by overdose/slythers@gmail.com
 Malloc(0) Wicked Attitude
 http://malloczerowickedattitude.new.fr

 created:10/03/2006
*/
#include <iostream.h>
#include "quantique.h"

class qbyte
{
 public:
  qbyte();
  bool error;
  unsigned int value;
  unsigned int know;
  static unsigned int ldepth;
  static unsigned int hdepth;
  bool multi(qbyte &un,unsigned int entier);
  bool add(qbyte &un,qbyte &deux);
  bool xor(qbyte &un,qbyte &deux);
  bool and(qbyte &un,qbyte &deux);
  bool or(qbyte &un,qbyte &deux);
  bool no(qbyte &un);
  void no();
  bool fusion(qbyte &of);
  void copy(qbyte &a);
  bool existbit(unsigned int number);
  void setbit(unsigned int number,bool value);
  void disablebit(unsigned int number);
  bool getbit(unsigned int number);
  void copyrealvalue();
  void setvalue();
  void setvalue(unsigned int v);
  void leftrotation(unsigned int nb);
  void rightrotation(unsigned int nb);
  void leftdecalage(unsigned int nb);
  void rightdecalage(unsigned int nb);
  //systeme de profondeur des erreur
  bool enabledepth();
  bool depthisenable();
  bool disabledepth();
  void reinitdepth();
  unsigned int getldepth();
  unsigned int gethdepth();
  unsigned int getredzone();
  bool depthsaved();
  bool enablecopyerror();
  bool disablecopyerror();
  //surcharge des opérateurs, be aware to memory leak
  struct quantparam * operator * (unsigned int constante);
  struct quantparam * operator + (qbyte &a);
  struct quantparam * operator + (struct quantparam * list);
  struct quantparam * operator | (qbyte &a);
  struct quantparam * operator | (struct quantparam * list);
  struct quantparam * operator & (qbyte &a);
  struct quantparam * operator & (struct quantparam * list);
  struct quantparam * operator ^ (qbyte &a);
  struct quantparam * operator ^ (struct quantparam * list);
  bool operator = (struct quantparam *list);
  bool operator = (qbyte &a);
  //machin amie
  friend ostream &operator << (ostream &sortie, qbyte &a)
  {
   sortie << "Quantique Bytes value: "<<hex<<a.me.value<<" Mask: "<<
a.me.know<<dec<<" Error:"<<a.error<<endl;
   return sortie;
  }
  struct quantique me;
 private:
  bool checkbitforadd(struct quantique *x,struct quantique *y,struct
quantique *z);
  bool checkbitforxor(struct quantique *x,struct quantique *y,struct
quantique *z);
  bool checkbitforand(struct quantique *x,struct quantique *y,struct
quantique *z);
  bool checkbitforor(struct quantique *x,struct quantique *y,struct
quantique *z);
  bool checkfusion(struct quantique *x,struct quantique *y);
  bool checkmulti(struct quantique *x,unsigned int entier,struct quantique
*z);
  bool pyramide(struct quantparam *list,char type);
  struct quantparam *addtolist(struct quantparam * list,char type);
  struct quantparam *newlist(qbyte &a,char type);
  void increment();
  void savedepth();
  void savedepth(bool b);
  static unsigned int compteur;
  static unsigned int compteur2;
  static unsigned int profondeur;
  static unsigned int profondeur2;
  static unsigned int redzone;
  static bool copyerror;
  static bool enable;
  static bool initialised;
  static bool saved;
};


the qbyte.cpp
-----------------------------------------------------------------------------
/*
(c) B4d coder
Malloc(0) Wicked Attitude

Copyright (c) 2006, overdose : slythers@gmail.com
All rights reserved.

private stuff

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/

#include "qbyte.h"

bool qbyte::initialised = 0;
unsigned int qbyte::ldepth;
unsigned int qbyte::hdepth;
unsigned int qbyte::compteur;
unsigned int qbyte::compteur2;
unsigned int qbyte::profondeur;
unsigned int qbyte::profondeur2;
unsigned int qbyte::redzone;
bool qbyte::copyerror;
bool qbyte::enable;
bool qbyte::saved;


qbyte::qbyte()
{
 this->value = 0x00;
 this->know = 0x00;
 me.value = 0x00;
 me.know = 0x00;
 error = 0;
 if(!initialised)
 {
  initialised = 1;
  copyerror = 1;
  disabledepth();
 }
}

bool qbyte::checkbitforadd(struct quantique *x,struct quantique *y,struct
quantique *z)
{
 bool modified=0;
 bool retenuemodified =0;
 bool retmod=0;
 unsigned int flagerror = 0x00;
 unsigned int mask;
 struct quantique save1,save2,save3;
 save1 = *x;
 save2 = *y;
 save3 = *z;
 struct quantique retenue;
 retenue.value = 0x00;
 retenue.know = 0x00;
 increment();
 do{
  if(modified)
   retmod = 1;
  modified = 0;
  retenuemodified = 0;
  mask = 0x01;
  for(unsigned char cpt = 0;cpt <32;cpt++)
  {
   //si on connait toute les valeurs on calcul la retenue et on se casse pas
   if((z->know & mask) && (x->know & mask) && (y->know & mask) && !(
retenue.know & mask))
   {
    /*if(retenue.know & mask)
     continue;*/
    if(!cpt)
    {
     retenuemodified = 1;
     retenue.know |= mask;
     if((x->value & mask) && (y->value & mask))
      retenue.value |= mask;
     else
      retenue.value &= ~mask;
    }
    else if(retenue.know & (mask>>1))
    {
     retenuemodified = 1;
     retenue.know |= mask;
     if(  ((x->value & mask) || (y->value & mask)) && ( ((x->value & mask)
&& (y->value & mask)) || (retenue.value & (mask>>1)) )  )
      retenue.value |= mask;
     else
      retenue.value &= ~mask;
    }
    else if(((x->value & mask) && (y->value & mask)))
    {
      retenuemodified = 1;
      retenue.know |= mask;
      retenue.value |= mask;
    };
    //continue;
   }
   //premier bit pas de retenue
   if(!cpt)
   {
    //au cas ou on connait la retenue
    if((retenue.know & mask) && (!(x->know & mask) || !(y->know & mask)) &&
(retenue.value & mask))
    {
     modified = 1;
     y->know |= mask;
     x->know |= mask;
     y->value |= mask;
     x->value |= mask;
    }
    else if((retenue.know & mask) && !(x->know & mask) && (y->know & mask)
&& (y->value & mask) && !(retenue.value & mask))
    {
     modified = 1;
     x->know |= mask;
     x->value &= ~mask;
    }
    else if((retenue.know & mask) && !(y->know & mask) && (x->know & mask)
&& (x->value & mask) && !(retenue.value & mask))
    {
     modified = 1;
     y->know |= mask;
     y->value &= ~mask;
    };
    //si on connait le bit du resultat
    if(z->know & mask)
    {
     //si on connait le bit de x a 1 et pas y
     if((x->know & mask) && (x->value & mask) && !(y->know & mask))
     {
      modified = 1;
      y->know |= mask;
      //on met y a 0
      if(z->value & mask)
       y->value &= ~mask;
      else
       y->value |= mask;
     }
     else if((x->know & mask) && !(x->value & mask) && !(y->know & mask))//
bit de x a 0
     {
      modified = 1;
      y->know |= mask;
      if(z->value & mask)
       y->value |= mask;
      else
       y->value &= ~mask;
     }
     //on connait y et pas x
     else if((y->know & mask) && (y->value & mask) && !(x->know & mask))
     {
      modified = 1;
      x->know |= mask;
      //on met y a 0
      if(z->value & mask)
       x->value &= ~mask;
      else
       x->value |= mask;
     }
     else if((y->know & mask) && !(y->value & mask) && !(x->know & mask) )//
bit de x a 0
     {
      modified = 1;
      x->know |= mask;
      if(z->value & mask)
       x->value |= mask;
      else
       x->value &= ~mask;
     }
    }
    //si on connait les deux !
    else if((x->know & mask) && (y->know & mask) && !(z->know & mask))
    {
     modified = 1;
     z->know |= mask;
     if( (x->value & mask) ^ (y->value & mask) )
      z->value |= mask;
     else
      z->value &= ~mask;
    };
    //calcul de la retenue
    if((x->know & mask) && (y->know & mask) && !(retenue.know & mask))
    {
     retenuemodified = 1;
     retenue.know |= mask;
     if((x->value & mask) && (y->value & mask))
      retenue.value |= mask;
     else
      retenue.value &= ~mask;
    }
    //on verifie les erreurs
    if((z->know & mask) && (x->know & mask) && (y->know & mask))
    {
     if(( (x->value & mask) ^ (y->value & mask) ) != (z->value & mask))
     {
      if(!(flagerror & mask))
      {
       flagerror |= mask;
       savedepth(1);
      }
      error = 1;
     }
    }
   }
   else
   {
    //au cas ou on connait la retenue courante et peut etre la precedente
pas z mais !a  | !b
    if((retenue.know & mask) && (!(x->know & mask) || !(y->know & mask))/*
&& !(z->know & mask)*/)
    {
     if((retenue.value & mask) && (retenue.know & (mask>>1)) && !(
retenue.value & (mask>>1)))
     {
      modified = 1;
      y->know |= mask;
      x->know |= mask;
      y->value |= mask;
      x->value |= mask;
     }
     else if((retenue.value & mask) && (retenue.know & (mask>>1)) && (
retenue.value & (mask>>1)))
     {
      if((x->know & mask) && !(x->value & mask) && !(y->know & mask))
      {
       modified = 1;
       y->know |= mask;
       y->value |= mask;
      }
      else if((y->know & mask) && !(y->value & mask) && !(x->know & mask))
      {
       modified = 1;
       x->know |= mask;
       x->value |= mask;
      };
     }
     else if((retenue.know & (mask>>1)) && (retenue.value & (mask>>1)) && !(
retenue.value & mask))
     {
      modified = 1;
      y->know |= mask;
      x->know |= mask;
      y->value &= ~mask;
      x->value &= ~mask;
     }
     else if((retenue.know & (mask>>1)) && !(retenue.value & (mask>>1)) &&
!(retenue.value & mask))
     {
      if((y->know & mask) && (y->value & mask) && !(x->know & mask))
      {
       modified = 1;
       x->know |= mask;
       x->value &= ~mask;
      }
      else if((x->know & mask) && (x->value & mask) && !(y->know & mask))
      {
       modified = 1;
       y->know |= mask;
       y->value &= ~mask;
      };
     }
     //au cas ou on connait pas la précendente valeur
     else if(!(retenue.know & (mask>>1)))
     {
      if((retenue.value & mask) && (x->know & mask) && !(x->value & mask))
      {
       modified = 1;
       y->know |= mask;
       y->value |= mask;
      }
      else if((retenue.value & mask) && (y->know & mask) && !(y->value &
mask))
      {
       modified = 1;
       x->know |= mask;
       x->value |= mask;
      };
     };
    }
    //calcul avec retenue precedente inconnu wesh
    if(!(retenue.know & (mask >> 1)))
    {
     if((retenue.know & mask) && (z->know & mask) && !(retenue.value & mask)
&& !(z->value & mask))
     {
      //cout <<"debug ret"<<endl;
      retenuemodified = 1;
      retenue.know |= (mask>>1);
      retenue.value &= ~(mask>>1);
     }
     //calcul de la retenu precedente
     if((x->know & mask) && (y->know & mask) && (z->know & mask))
     {
      retenuemodified = 1;
      retenue.know |= (mask >> 1);
      if( ((x->value & mask) ^ (y->value & mask)) ^ (z->value & mask))
       retenue.value |= (mask >> 1);
      else
       retenue.value &= ~(mask >> 1);
     }
     //on connait la retenue actuel et x et y
     else if((x->know & mask) && (y->know & mask) && (retenue.know & mask))
     {
      //si Rx=1 et !(x&&y) alors rx-1 = 1
      if((retenue.value & mask)  && !((x->value & mask) && (y->value &
mask)))
      {
       //cout <<"debug 17"<<endl;
       retenuemodified = 1;
       retenue.know |= (mask>>1);
       retenue.value |= (mask>>1);
      }
      // si rx = 0 et x||y rx-1 = 0
      else if(!(retenue.value & mask) && ((x->value & mask) || (y->value &
mask)) )
      {
       retenuemodified = 1;
       retenue.know |= (mask>>1);
       retenue.value &= ~(mask>>1);
      };
     };
    }
    //calcul avec retenue precedente connu
    else if( retenue.know & (mask >> 1))
    {
     if((x->know & mask) && (y->know & mask) && !(z->know & mask))
     {
      modified = 1;
      z->know |= mask;
      if((x->value & mask) ^ (y->value & mask) ^ ((retenue.value &
(mask>>1))<<1))
       z->value |= mask;
      else
       z->value &= ~mask;
     }
     else if((x->know & mask) && !(y->know & mask) && (z->know & mask))
     {
      modified = 1;
      y->know |= mask;
      if((x->value & mask) ^ (z->value & mask) ^ ((retenue.value &
(mask>>1))<<1))
       y->value |= mask;
      else
       y->value &= ~mask;
     }
     else if(!(x->know & mask) && (y->know & mask) && (z->know & mask))
     {
      modified = 1;
      x->know |= mask;
      if((z->value & mask) ^ (y->value & mask) ^ ((retenue.value &
(mask>>1))<<1))
       x->value |= mask;
      else
       x->value &= ~mask;
     };
     //calcul retenu
     if(!(retenue.know & mask) && (x->know & mask) && !(y->know & mask) &&
!(z->know & mask) )
     {
      if(!(retenue.value & (mask>>1)) && !(x->value & mask))
      {
       retenuemodified = 1;
       retenue.know |= mask;
       retenue.value &= ~mask;
      }
      else if((retenue.value & (mask>>1)) && (x->value & mask))
      {
       retenuemodified = 1;
       retenue.know |= mask;
       retenue.value |= mask;
      };
     }
     else if(!(retenue.know & mask) && (y->know & mask) && !(x->know & mask)
&& !(z->know & mask))
     {
      if(!(retenue.value & (mask>>1)) && !(y->value & mask))
      {
       retenuemodified = 1;
       retenue.know |= mask;
       retenue.value &= ~mask;
      }
      else if((retenue.value & (mask>>1)) && (y->value & mask))
      {
       retenuemodified = 1;
       retenue.know |= mask;
       retenue.value |= mask;
      };
     };
    }
    //calcul de la retenu
    if(!(retenue.know & mask) && (retenue.know & (mask>>1)) && (x->know &
mask) && (y->know & mask))
    {
     retenuemodified = 1;
     retenue.know |= mask;
     if( ((x->value & mask) && (y->value & mask)) || ((x->value & mask) && (
retenue.value & (mask>>1))) || ((retenue.value & (mask>>1)) && (y->value &
mask)) )
      retenue.value |= mask;
     else
      retenue.value &= ~mask;
    }
    else if(!(retenue.know & mask) && !(retenue.know & (mask>>1)) &&
(x->know & mask) && (y->know & mask) && (x->value & mask) && (y->value &
mask))
    {
     retenuemodified = 1;
     retenue.know |= mask;
     retenue.value |= mask;
    }
    else if(!(retenue.know & mask) && (retenue.know & (mask>>1)) && (x->know
& mask) && !(y->know & mask) && !(retenue.value & (mask>>1)) && !(x->value &
mask))
    {
     retenuemodified = 1;
     retenue.know |= mask;
     retenue.value &= ~mask;
    }
    else if(!(retenue.know & mask) && (retenue.know & (mask>>1)) &&
!(x->know & mask) && (y->know & mask) && !(retenue.value & (mask>>1)) &&
!(y->value & mask))
    {
     retenuemodified = 1;
     retenue.know |= mask;
     retenue.value &= ~mask;
    };
    if((x->know & mask) && (y->know & mask) && !(x->value & mask) &&
!(y->value & mask) && !(retenue.know & mask) )
    {
     //cout <<"debug ret 2"<<endl;
     retenuemodified = 1;
     retenue.know |= mask;
     retenue.value &= ~mask;
    }
    else if((x->know & mask) && (y->know & mask) && (x->value & mask) &&
(y->value & mask) && !(retenue.know & mask) )
    {
     //cout <<"debug ret 3"<<endl;
     retenuemodified = 1;
     retenue.know |= mask;
     retenue.value |= mask;
    }
   }
  //on verifie les erreurs
  if((z->know & mask) && (x->know & mask) && (y->know & mask) && cpt && (
retenue.know & (mask>>1)))
  {
   if(( (x->value & mask) ^ (y->value & mask) ^ ((retenue.value &
(mask>>1))<<1) ) != (z->value & mask))
   {
    if(!(flagerror & mask))
    {
     flagerror |= mask;
     savedepth(1);
    }
    error = 1;
   }
  }
  mask = mask <<1;
  }
 }while(modified || retenuemodified);
 //verification des erreur
 if(!(~(x->know)) && !(~(y->know)) && !(~(z->know)))
 {
  if((x->value + y->value) != z->value)
  {
   savedepth();
   error = 1;
  }
 }
 if((save1.value & save1.know) != (x->value & save1.know))
 {
  savedepth();
  error = 1;
 }
 if((save2.value & save2.know) != (y->value & save2.know))
 {
  savedepth();
  error = 1;
 }
 if((save3.value & save3.know) != (z->value & save3.know))
 {
  savedepth();
  error = 1;
 }
 return retmod;
}

//version fast ...
bool qbyte::checkmulti(struct quantique *x,unsigned int entier,struct
quantique *z)
{
 struct quantique pile[32];
 struct quantique palier;
 struct quantique copiedex;
 struct quantique cx,cz;
 unsigned int mask;
 unsigned char cpt,nb,max;
 bool modified=0;
 cx = *x;
 cz = *z;
 palier.value = 0x00;
 palier.know = 0x00;
 nb = 0;
 increment();
 for(cpt =0; cpt<32;cpt++)
 {
  pile[cpt].value = 0x00;
  pile[cpt].know = 0x00;
 }
 for(max =31;!((0x01<<max) & entier) && max ;max--);
 pile[0].know = 0xffffffff;
 do{
  modified = 0;
  mask = 0x01<<31;
  nb = 0;
  for(cpt=0;cpt<32;cpt++)
  {
   if(mask & entier)
   {
    palier.value = x->value << (31-cpt);
    palier.know = (x->know << (31-cpt)) | ((cpt == 31) ? 0x00 : (0xffffffff
>> (cpt+1)) );
    if(checkbitforadd(&(pile[nb]),&palier, (cpt == max)? z : &(pile[nb+1])
))
     modified = 1;
    nb++;
    palier.value = palier.value >> (31-cpt);
    palier.know = palier.know >> (31-cpt);
    copiedex.know = x->know;
    if(checkfusion(&palier,x))
    {
     if(copiedex.know != x->know)
      modified = 1;
    }
   }
   mask = mask >>1;
  }
  //on refait dans l'autre sens
  for(;cpt;cpt--)
  {
   if(mask & entier)
   {
    palier.value = (x->value) << (31-(cpt-1));
    palier.know = (x->know) << (31-(cpt-1)) | ((cpt == 32) ? 0x00 :
(0xffffffff >> (cpt)) );
    if(checkbitforadd(&(pile[nb]),&palier, (cpt == (max+1))? z :
&(pile[nb+1]) ))
     modified = 1;
    nb--;
    palier.value = (palier.value) >> (31-(cpt-1));
    palier.know = (palier.know) >> (31-(cpt-1));
    copiedex.know = x->know;
    if(checkfusion(&palier,x))
    {
     if(copiedex.know != x->know)
      modified = 1;
    }
   }
   mask = mask <<1;
  }
 }while(modified && !error);
 //verification erreur
 if(cx.value != (x->value & cx.know))
 {
  savedepth();
  error = 1;
 }
 if(cz.value != (z->value & cz.know))
 {
  savedepth();
  error = 1;
 }
 if((cz.know != z->know) || (cx.know != x->know))
  return 1;
 return 0;
}

bool qbyte::checkbitforxor(struct quantique *x,struct quantique *y,struct
quantique *z)
{
 bool modified=0;
 unsigned int mask=0x01;
 unsigned int tmp;
 unsigned int flagerror=0x00;
 increment();
 tmp = z->know & x->know & y->know;
 if((z->value & tmp) != ((x->value & tmp) ^ (y->value & tmp)))
 {
  savedepth();
  error = 1;
 }
 for(unsigned int cpt = 0;cpt<32;cpt++)
 {
  if(z->know & mask)
  {
   if(z->value & mask)
   {
    if((x->know & mask) && (x->value & mask))
    {
     //cout <<"debug 1"<<endl;
     if(!(y->know & mask))
      modified = 1;
     y->know |= mask;
     y->value &= ~mask;
    }
    else if((y->know & mask) && (y->value & mask))
    {
     //cout <<"debug 2"<<endl;
     if(!(x->know & mask))
      modified = 1;
     x->know |= mask;
     x->value &= ~mask;
    };
   }
   else
   {
    if(x->know & mask)
    {
     //cout <<"debug 3"<<endl;
     if(!(y->know & mask))
      modified = 1;
     y->know |= mask;
     if(x->value&mask)
      y->value |= mask;
     else
      y->value &= ~mask;
    }
    else if(y->know & mask)
    {
     //cout <<"debug 4"<<endl;
     //inutile ici mais bon =)
     if(!(x->know & mask))
      modified = 1;
     x->know |= mask;
     if(y->value&mask)
      x->value |= mask;
     else
      x->value &= ~mask;
    };
   }
  }
  else if((x->know & mask) && (y->know & mask))
  {
   //cout <<"debug 5"<<endl;
   modified = 1;
   z->know |= mask;
   if((x->value & mask) ^ (y->value & mask))
    z->value |= mask;
   else
    z->value &= ~mask;
  };
  //on check les erreur
  if((z->know & mask) && (x->know & mask) && (y->know & mask))
  {
   if((z->value & mask) != ((x->value & mask) ^ (y->value & mask)))
   {
    if(!(flagerror & mask))
    {
     flagerror |= mask;
     savedepth(1);
    }
    error = 1;
   }
  }
  mask = mask << 1;
 }
 return modified;
}

bool qbyte::checkbitforand(struct quantique *x,struct quantique *y,struct
quantique *z)
{
 bool modified=0;
 unsigned int mask=0x01;
 unsigned int flagerror = 0x00;
 unsigned int tmp;
 increment();
 tmp = z->know & x->know & y->know;
 if((z->value & tmp) != ((x->value & tmp) & (y->value & tmp)))
 {
  savedepth();
  error = 1;
 }
 for(unsigned int cpt = 0;cpt<32;cpt++)
 {
  if((z->know & mask) && (z->value & mask))
  {
   if(!((x->know & mask) && (y->know & mask)) )
    modified = 1;
   x->know |= mask;
   y->know |= mask;
   x->value |= mask;
   y->value |= mask;
  }
  else if((z->know & mask) && !(z->value & mask))
  {
   if((x->know & mask)&&(x->value & mask))
   {
    if(!(y->know & mask))
     modified = 1;
    y->know |= mask;
    y->value &= ~mask;
   }
   else if((y->know & mask)&&(y->value & mask))
   {
    if(!(x->know & mask))
     modified = 1;
    x->know |= mask;
    x->value &= ~mask;
   };
  }
  else if(!(z->know & mask) && ((x->know & mask) || (y->know & mask)))
  {
   if((x->know & mask) && !(x->value & mask))
   {
    modified = 1;
    z->know |= mask;
    z->value &= ~mask;
   }
   else if((y->know & mask) && !(y->value & mask))
   {
    modified = 1;
    z->know |= mask;
    z->value &= ~mask;
   }
   else if((x->know & mask) && (y->know & mask))// normelement les deux sont
a 1
   {
    modified = 1;
    z->know |= mask;
    z->value |= mask;
   }
  };
  //on check les erreur
  if((z->know & mask) && (x->know & mask) && (y->know & mask))
  {
   if((z->value & mask) != ((x->value & mask) & (y->value & mask)))
   {
    if(!(flagerror & mask))
    {
     flagerror |= mask;
     savedepth(1);
    }
    error = 1;
   }
  }
  mask = mask<<1;
 }
 return modified;
}

bool qbyte::checkbitforor(struct quantique *x,struct quantique *y,struct
quantique *z)
{
 bool modified=0;
 unsigned int mask=0x01;
 unsigned int tmp;
 unsigned int flagerror = 0x00;
 increment();
 tmp = z->know & x->know & y->know;
 if((z->value & tmp) != ((x->value & tmp) | (y->value & tmp)))
 {
  savedepth();
  error = 1;
 }
 for(unsigned int cpt = 0;cpt<32;cpt++)
 {
  if((z->know & mask) && !(z->value & mask))
  {
   if(!((x->know & mask) && (y->know & mask)) )
    modified = 1;
   x->know |= mask;
   y->know |= mask;
   x->value &= ~mask;
   y->value &= ~mask;
  }
  else if((z->know & mask) && (z->value & mask))
  {
   if((x->know & mask) && !(x->value & mask))
   {
    if(!(y->know & mask))
     modified = 1;
    y->know |= mask;
    y->value |= mask;
   }
   else if((y->know & mask) && !(y->value & mask))
   {
    if(!(x->know & mask))
     modified = 1;
    x->know |= mask;
    x->value |= mask;
   };
  }
  else if(!(z->know & mask) && ((x->know & mask) || (y->know & mask)))
  {
   if((x->know & mask) && (x->value & mask))
   {
    modified = 1;
    z->know |= mask;
    z->value |= mask;
   }
   else if((y->know & mask) && (y->value & mask))
   {
    modified = 1;
    z->know |= mask;
    z->value |= mask;
   }
   else if((x->know & mask) && (y->know & mask))// normelement le deux sont
a 0
   {
    modified = 1;
    z->know |= mask;
    z->value &= ~mask;
   }
  };
  //on check les erreur
  if((z->know & mask) && (x->know & mask) && (y->know & mask))
  {
   if((z->value & mask) != ((x->value & mask) | (y->value & mask)))
   {
    if(!(flagerror & mask))
    {
     flagerror |= mask;
     savedepth(1);
    }
    error = 1;
   }
  }
  mask = mask<<1;
 }
 return modified;
}

bool qbyte::multi(qbyte &un,unsigned int entier)
{
 bool ret;
 error |= un.error ;
 if(error)
  return 0;
 ret = checkmulti(&(un.me),entier,&(this->me));
 copyrealvalue();
 return ret;
}

bool qbyte::add(qbyte &un,qbyte &deux)
{
 bool ret;
 error |= un.error | deux.error;
 /*if(error)
  return 0;*/
 ret = checkbitforadd(&(un.me),&(deux.me),&(this->me));
 copyrealvalue();
 return ret;
}

bool qbyte::xor(qbyte &un,qbyte &deux)
{
 bool ret;
 error |= un.error | deux.error;
 /*if(error)
  return 0;*/
 ret = checkbitforxor(&(un.me),&(deux.me),&(this->me));
 copyrealvalue();
 return ret;
}

bool qbyte::and(qbyte &un,qbyte &deux)
{
 bool ret;
 error |= un.error | deux.error;
 /*if(error)
  return 0;*/
 ret = checkbitforand(&(un.me),&(deux.me),&(this->me));
 copyrealvalue();
 return ret;
}

bool qbyte::or(qbyte &un,qbyte &deux)
{
 bool ret;
 error |= un.error | deux.error;
 /*if(error)
  return 0;*/
 ret = checkbitforor(&(un.me),&(deux.me),&(this->me));
 copyrealvalue();
 return ret;
}

bool qbyte::no(qbyte &un)
{
 bool modified=0;
 unsigned int mask=0x01;
 unsigned int tmp;
 struct quantique *x;
 increment();
 x = &(un.me);
 tmp = me.know & x->know;
 if((me.value & tmp) != (~(x->value) & tmp) )
 {
  savedepth();
  error = 1;
 }
 for(unsigned int cpt = 0;cpt<32;cpt++)
 {
  if((me.know & mask) && !(x->know & mask))
  {
   modified = 1;
   x->know |= mask;
   if(me.value & mask)
    x->value &= ~mask;
   else
    x->value |= mask;
  }
  else if(!(me.know & mask) && (x->know & mask))
  {
   modified = 1;
   x->know |= mask;
   if(x->value & mask)
    me.value &= ~mask;
   else
    me.value |= mask;
  };
  if( (me.know & mask) && (x->know & mask) && ((me.value & mask) !=
(~(x->value) & mask)) )
  {
   savedepth(1);
   error = 1;
  }
  mask = mask << 1;
 }
 copyrealvalue();
 return modified;
}

void qbyte::no()
{
 me.value = ~(me.value);
 me.value &= me.know;
 copyrealvalue();
}

bool qbyte::checkfusion(struct quantique *x,struct quantique *y)
{
 bool modified=0;
 unsigned int mask=0x01;
 increment();
 for(unsigned int cpt = 0;cpt<32;cpt++)
 {
  if(x->know & mask)
  {
   if((y->know & mask) && ((x->value & mask) != (y->value & mask)) )
   {
    savedepth(1);
    error = 1;
   }
   if(!(y->know & mask))
    modified = 1;
   y->know |= mask;
   if(x->value & mask)
    y->value |= mask;
   else
    y->value &= ~mask;
  }
  else if(y->know & mask)
  {
   modified = 1;
   x->know |= mask;
   if(y->value & mask)
    x->value |= mask;
   else
    x->value &= ~mask;
  }
  mask = mask << 1;
 }
 return modified;
}

bool qbyte::fusion(qbyte &of)
{
 bool modified=0;
 modified = checkfusion(&(of.me),&(this->me));
 copyrealvalue();
 return modified;
}

void qbyte::copy(qbyte &a)
{
 me.value = a.me.value;
 me.know = a.me.know;
 if(copyerror)
  this->error = a.error;
 copyrealvalue();
}

void qbyte::setbit(unsigned int number,bool value)
{
 me.know |= (0x01<<number);
 if(value)
  me.value |= (0x01<<number);
 else
  me.value &= ~(0x01<<number);
 copyrealvalue();
}

bool qbyte::existbit(unsigned int number)
{
 return (me.know & (0x01<<number));
}

void qbyte::disablebit(unsigned int number)
{
 me.know &= ~(0x01<<number);
 me.value  &= me.know;
 copyrealvalue();
}

bool qbyte::getbit(unsigned int number)
{
 return (me.value & (0x01<<number));
}

void qbyte::copyrealvalue()
{
 this->value = me.value;
 this->know = me.know;
}

void qbyte::setvalue()
{
 me.value = this->value & this->know ;
 me.know = this->know;
}

void qbyte::setvalue(unsigned int v)
{
 me.value = v;
 me.know = 0xffffffff;
}

void qbyte::leftrotation(unsigned int nb)
{
 if(!(nb %32))
  return;
 me.value = ( ((me.value) << (nb)) | ((me.value) >> (32-(nb))) );
 me.know = ( ((me.know) << (nb)) | ((me.know) >> (32-(nb))) );
 copyrealvalue();
}

void qbyte::rightrotation(unsigned int nb)
{
 if(!(nb %32))
  return;
 me.value = (((me.value) >> (nb)) | ((me.value) << (32-(nb))));
 me.know = (((me.know) >> (nb)) | ((me.know) << (32-(nb))));
 copyrealvalue();
}

void qbyte::leftdecalage(unsigned int nb)
{
 me.value = me.value << nb;
 me.know = me.know << nb;
 copyrealvalue();
}

void qbyte::rightdecalage(unsigned int nb)
{
 me.value = me.value >> nb;
 me.know = me.know >> nb;
 copyrealvalue();
}

//surcharge des operateurs
//a debugguer ... surtout le return modif faut checker que les entrée/sorie
qui pourrait avoir changer
bool qbyte::pyramide(struct quantparam *list,char type)
{
 struct quantique abc[MAX_ADD][MAX_ADD/2];
 unsigned char endessous[MAX_ADD];
 unsigned char nbporte[MAX_ADD];
 unsigned char cpt,ptr,hauteur,tmp;
 bool modified=0;
 bool ret;
 ret =0;
 if(list->nb < 3)
 {
  switch(type)
  {
   case '+':
    return checkbitforadd(list->wesh[0],list->wesh[1],&(this->me));
   case '|':
    return checkbitforor(list->wesh[0],list->wesh[1],&(this->me));
   case '&':
    return checkbitforand(list->wesh[0],list->wesh[1],&(this->me));
   case '^':
    return checkbitforxor(list->wesh[0],list->wesh[1],&(this->me));
   case '*':
    return checkmulti(list->wesh[0],(unsigned int)
list->wesh[1],&(this->me));
  }
  return 0;
 }
 for(cpt=0;cpt<MAX_ADD;cpt++)
 {
  endessous[cpt] = 0xff;
  for(ptr=0;ptr < (MAX_ADD/2);ptr++)
  {
   abc[cpt][ptr].know = 0x00;
   abc[cpt][ptr].value = 0x00;
  }
 }
 do{
  if(modified)
   ret = 1;
  modified = 0;
  //on divise une premere fois par deux
  hauteur = list->nb/2;
  if(hauteur %2)
   hauteur++;
  hauteur -= 2;
  hauteur = hauteur/2;
  tmp = list->nb;
  if(tmp%2)
  {
   abc[(tmp/2)+1][0] = *(list->wesh[tmp]);
   endessous[0] = tmp;
   tmp = tmp /2;
   nbporte[0] = tmp;
   tmp++;
  }
  else
  {
   tmp = tmp /2;
   nbporte[0] = tmp;
  }
  for(unsigned char ok=0;ok < list->nb;ok+=2)
  {
   switch(type)
   {
    case '+':
     checkbitforadd(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));
     break;
    case '|':
     checkbitforor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));
     break;
    case '&':
     checkbitforand(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));
     break;
    case '^':
     checkbitforxor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));
     break;
   }
  }
  for(cpt = 0;cpt < hauteur;cpt++)
  {
   if(tmp%2)
   {
    abc[(tmp/2)+1][cpt+1] = abc[tmp][cpt];
    endessous[cpt+1] = tmp;
    tmp = tmp /2;
    nbporte[cpt+1] = tmp;
    tmp++;
   }
   else
   {
    tmp = tmp /2;
    nbporte[cpt+1] = tmp;
   }

   for(ptr=0;ptr < nbporte[cpt+1];ptr++)
   {
    switch(type)
    {
     case '+':
      checkbitforadd(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));
      break;
     case '|':
      checkbitforor(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));
      break;
     case '&':
      checkbitforand(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));
      break;
     case '^':
      checkbitforxor(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));
      break;
    }
   }
  }
  switch(type)
  {
   case '+':
    if(checkbitforadd(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))
     modified = 1;
    break;
   case '|':
    if(checkbitforor(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))
     modified = 1;
    break;
   case '&':
    if(checkbitforand(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))
     modified = 1;
    break;
   case '^':
    if(checkbitforxor(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))
     modified = 1;
    break;
  }
  //on refait dans l'autre sens peut etre on aura pas besoin de boucler ^^ a
verifier
  if(endessous[cpt] != 0xff)
   abc[endessous[cpt]][cpt-1] = abc[1][cpt];
  for(;cpt;cpt--)
  {
   for(ptr=0; ptr < nbporte[cpt];ptr++)
   {
    switch(type)
    {
     case '+':
      checkbitforadd(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));
      break;
     case '|':
      checkbitforor(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));
      break;
     case '&':
      checkbitforand(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));
      break;
     case '^':
      checkbitforxor(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));
      break;
    }
   }
   if(endessous[cpt] != 0xff)
    abc[endessous[cpt]][cpt-1] = abc[ptr+1][cpt];
  }
  if(endessous[0] != 0xff)
   *(list->wesh[tmp]) = abc[nbporte[cpt]][0];
  for(unsigned char ok=0;ok < list->nb;ok+=2)
  {
   switch(type)
   {
    case '+':
     if(checkbitforadd(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))
      modified = 1;
     break;
    case '|':
     if(checkbitforor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))
      modified = 1;
     break;
    case '&':
     if(checkbitforand(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))
      modified = 1;
     break;
    case '^':
     if(checkbitforxor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))
      modified = 1;
     break;
   }
  }
 }while(modified);
 delete[] (char *)list;
 return ret;
}

struct quantparam *qbyte::newlist(qbyte &a,char type)
{
 struct quantparam *abc;
 abc = (struct quantparam *) new char[PARAM_LIST_SIZE_BASE + (sizeof(struct
quantique *)*2)];
 abc->size = PARAM_LIST_SIZE_BASE + (sizeof(struct quantique *)*2);
 abc->type = type;
 abc->nb = 2;
 abc->error = this->error | a.error;
 abc->wesh[0] = &(this->me);
 abc->wesh[1] = &(a.me);
 return abc;
}

struct quantparam *qbyte::addtolist(struct quantparam * list,char type)
{
 struct quantparam *tmp;
 if(type != list->type)
 {
  cout <<"wesh lascar, on supporte pas trop les melange sur ste version
modif ton code  la lib fait un exit(0); la:P"<<endl;
  exit(0);
 }
 tmp = (struct quantparam *) new char[list->size + sizeof(struct quantique
*)];
 memcpy(tmp,list,list->size);
 tmp->wesh[list->nb] = &(this->me);
 delete[] (char *)list;
 tmp->nb++;
 return tmp;
}

struct quantparam * qbyte::operator + (qbyte &a)
{
 return newlist(a,'+');
}

struct quantparam * qbyte::operator + (struct quantparam * list)
{
 return addtolist(list,'+');
}

bool qbyte::operator = (struct quantparam *list)
{
 return pyramide(list,list->type);
}

bool qbyte::operator = (qbyte &a)
{
 return fusion(a);
}

struct quantparam * qbyte::operator | (qbyte &a)
{
 return newlist(a,'|');
}

struct quantparam * qbyte::operator | (struct quantparam * list)
{
 return addtolist(list,'|');
}

struct quantparam * qbyte::operator & (qbyte &a)
{
 return newlist(a,'&');
}

struct quantparam * qbyte::operator & (struct quantparam * list)
{
 return addtolist(list,'&');
}

struct quantparam * qbyte::operator ^ (qbyte &a)
{
 return newlist(a,'^');
}

struct quantparam * qbyte::operator ^ (struct quantparam * list)
{
 return addtolist(list,'^');
}

struct quantparam * qbyte::operator * (unsigned int constante)
{
 struct quantparam *abc;
 abc = (struct quantparam *) new char[PARAM_LIST_SIZE_BASE + (sizeof(struct
quantique *)*2)];
 abc->size = PARAM_LIST_SIZE_BASE + (sizeof(struct quantique *)*2);
 abc->type = '*';
 abc->nb = 2;
 abc->error = this->error ;
 abc->wesh[0] = &(this->me);
 abc->wesh[1] = (struct quantique *) constante;
 return abc;
}

//profondeur d'erreur ...
void qbyte::increment()
{
 if(!enable)
  return;
 if(saved)
 {
  //redzone++;
  return ;
 }
 if(compteur == ~0x00)
  compteur2++;
 compteur++;
}

void qbyte::savedepth()
{
 savedepth(0);
}

void qbyte::savedepth(bool b)
{
 if(!enable)
  return;
 if(saved)
 {
  if(b)
   redzone++;
  return;
 }
 profondeur = compteur;
 profondeur2 = compteur2;
 ldepth = compteur;
 hdepth = compteur2;
 saved = 1;
 redzone = 1;
}

bool qbyte::enabledepth()
{
 reinitdepth();
 if(enable)
  return 0;
 enable = 1;
 return 1;
}

bool qbyte::depthisenable()
{
 return enable;
}

bool qbyte::disabledepth()
{
 if(!enable)
  return 0;
 enable = 0;
 reinitdepth();
 return 1;
}

void qbyte::reinitdepth()
{
 compteur  = 0;
 compteur2 = 0;
 profondeur = 0;
 profondeur2 = 0;
 ldepth = 0;
 hdepth = 0;
 redzone = 0;
 saved = 0;
}

unsigned int qbyte::getldepth()
{
 if(saved)
  return profondeur;
 else
  return compteur;
}

unsigned int qbyte::gethdepth()
{
 if(saved)
  return profondeur2;
 else
  return compteur2;
}

unsigned int qbyte::getredzone()
{
 return redzone;
}

bool qbyte::depthsaved()
{
 return saved;
}

bool qbyte::enablecopyerror()
{
 if(copyerror)
  return 0;
 copyerror = 1;
 return 1;
}

bool qbyte::disablecopyerror()
{
 if(!copyerror)
  return 0;
 copyerror = 0;
 return 1;
}