bigint& bigint::operator/=(const bigint& autre)
{
  if (autre.used==0)
    return *this;
  int n=autre.used;
  int m=used-n;
  alloc=m+1+DEFAULT_LEN;
  if (alloc<used+1)
    realloc(used+DEFAULT_LEN+1,true);
  int* data_tmp=new (std::nothrow) int[alloc];
  for (int i=0;i<alloc;i++)
    data_tmp[i]=0;
  signe=(signe==autre.signe);

  int d=BASE/(autre.data[n-1]+1);
  operator*=(d);
  bigint v(autre,INT_SIZE+2);
  v*=d;
  m=used-n-1;   //n==v.used car la normalisation de v ne change pas sa longueur.
  
  for (int j=m;j>=0;j--)
  {
    int q=(data[j+n]*BASE+data[j+n-1])/v.data[n-1];
    int rr=(data[j+n]*BASE+data[j+n-1])%v.data[n-1];
    do
    {
      if (q>=BASE || (long long)(((long long)q)*v.data[n-2])>(long long)((long long)BASE*rr+data[j+n-2]))
      {
        q-=1;
        rr+=v.data[n-1];
      }
      else
        break;
    }while(1);;//rr<BASE);
/*
   ALTERNATIVEMENT
    int q;
    if (data[j+n]==v.data[n-1])
      q=BASE-1;
    else
      q=(data[j+n]*BASE+data[j+n-1])/v.data[n-1];
    while (q*v.data[n-2]>(data[j+n]*BASE+data[j+n-1])*BASE+data[j+n-2])
      q--;
*/
    data_tmp[j]=q;
    int r=0;
    for (int i=0;i<=n;i++)    //on lis au-delà de v.used, mais cela a été arrangé dans le constructeur de v.
    {
      data[j+i]-=q*v.data[i]+r;
      if (data[j+i]<0)        //dans tout les cas q>0 donc il n'y a pas de problème de retenu de l'autre coté.
      {
        r=(-data[j+i])/BASE+1;
        data[j+i]+=r*BASE;
      }
      else
        r=0;
    }
    if (r>0)
    {
      data_tmp[j]-=1;
      int rb=0;
      for (int i=0;i<=n;i++)
      {
        rb+=v.data[i];
        data[j+i]+=(rb%BASE);
        rb/=BASE;
      } //la retenu au bout ne gène pas, c'est elle qu'on veut virer.
      r-=rb;
    }
  }

  delete[] data;
  data=data_tmp;
  find_used(m+1);
  return *this;
}

/*
  Mais le problème est que le tout est bogué.
  Dans certain cas (tout le temps), après une division, un nombre qui devrait avoir la forme 123456700000 est obtenu sous la forme 123456699999.
*/