// ############################## START FUNC ############################################
// With the fallowing routine, an ordination for how many steps the later procedure for chirality
// checking will procede. The number of steps is analogue to how many consecutive advancements 
// atoms-to-atoms from all chiral atoms that are needed to get the priority of ALL relevant branches.

function prepare_chir(atom_sorts, mconn, poschir)
{

     var number_of_atoms=atom_sorts.length;
     var status_before = new List("empty", 0, atom_sorts); 
     var latest_all_different=0;
     var tal1=new Array(number_of_atoms);
     var tal2=new Array(number_of_atoms);
     var helpstring=poschir.Display();
     var chirlist=helpstring.split(" ");
     var w=0;
     var p=0;
     var n=0;
     var q=0;
     var logicalvv=false;

// tal1 and tal2 is the value of each atom before, respective after, the atom-to-atom
// value recombination. The resulting values say nothing about priority, but obviously
// two atoms with the same numbers are likely to have been under the same influences
// with respect to the reach for the number of loops. So if p has reached the value of 9
// all atoms have recieved influences from atoms as far as 10 atom-to-atoms neighbours
// away. However, this may be incorrect for small influences. This problem can be managed
// by enchancements of fraction decimals into the main number.

  for(n=0;n<number_of_atoms;n++){
  tal2[n]=0;
  tal1[n]=0;
  }

// ------------
for(p=0;p<number_of_atoms;p++){

// There are no use to continue beyond the point where all atoms in the list are
// already determinable.

if(status_before.Span()==poschir.Span()) break;

for(n=0;n<number_of_atoms;n++){
for(q=0;q<mconn[n].length;q++){
tal2[mconn[n][q]]=parseFloat(tal2[mconn[n][q]])+parseFloat(tal1[n]/2)+parseFloat(atom_sorts[n]);
}
}

// The handling above is really the main operation to proceede one step atom-to-atom.
// Below, the same routine which can be seen in many other functions as well is used
// to turn after-values from the loop p to before-values for the next loop p+1.

  // &&&&&&&&&&&&&
  for(n=0;n<number_of_atoms;n++){
  tal1[n]=tal2[n]/2;
  tal2[n]=0;
  }
  // &&&&&&&&&&&&&

// The fallowing block *** sets an new latest_all_different in the row next to the end
// if all branches of a chiral atom chirlist[w] has precisely became differentiable by
// the latest loop-> if(!status_before.Check(chirlist[w]) && logicalvv)
// i.e. false before, true now. Along with potential chiral atoms, double bonds which to
// theirs configuration cis-trans, depends on the same priority rules, are tested here.
// In this function, opposed to the latter, information is exchanged over the central C=C.
// It should not matter.

       // ****************
       for(w=0;w<chirlist.length;w++){
        if(status_before.Check(chirlist[w])) continue;
       logicalvv=true;

// To keep logicalvv true, all combinations of neighbour values must be different.
// The loop q=1 and up gives one neighbour value and the second loop n=1 and up gives
// the value of a second neighbour. All combinations are tested.

         for(q=1;q<mconn[chirlist[w]].length;q++){
         for(n=0;n<q;n++){
          if(tal1[mconn[chirlist[w]][q]]==tal1[mconn[chirlist[w]][n]]){
          logicalvv=false;
          break;
          }
         }
          if(!logicalvv) break;   // If two neighbour values are equal, further steps must be taken.
         }
        if(!status_before.Check(chirlist[w]) && logicalvv) latest_all_different=p;
        if(logicalvv) status_before.Add(chirlist[w]);
       }
       // ****************

}
// ------------

return latest_all_different;
}
// ############################### end func ############################################