// ############################## START FUNC ############################################
// This function replace all atom_ID:s with respective atom weight/100 - so that
// it will be sorted correctly in JavaScript

function substitute(comb1, atom_sorts)
{

     var number_of_atoms = atom_sorts.length;
     var n=0;
     var saml2="";
     var temp="";
     var temp2="";
     var dump="";
     var tupp = new Array(0);

// Each path will be fallowed by:
// (1) the atom-ID of the start atom, which is checked for chirality and conformation, and
// (2) the atom-ID of the first neighbour atom. This will look like this, EXAMPLE:
// "0.06 0.08 &5  0.08 0.06 &1  0.06 0.08 &5  0.08 0.06 &1  0.06 0.06 &1  /1//7/#"
// In this case atom no. 1 was on the list of possible chiral atoms. Atom no. 7 is one
// of its direct neighbour atoms leading out to the fallowing branch above. So the part
// "0.06 0.08 &5  0.08" in the beginning of the excerpt is in reality redundant. Theese
// values is the atom sorts for the 1:st and 7:th atom. "&5" denote that atom no. 1 (NOT no.7)
// is an atom with four non hydrogen neighbours. 

       for(n=0;n<comb1.length;n++){
       temp=comb1[n];
// Cis- trans- branches are marked with "x"
       if(temp.charAt(0)=="x") temp=temp.substring(1,temp.length);
       temp=temp.substring(1,temp.indexOf(" ",1));
       tupp=temp.split("->");
       temp=tupp.join("//");
       comb1[n]=comb1[n]+" /"+temp+"/";
       }

     saml2=comb1.join("##");
     comb1=saml2.split("->");
     saml2=comb1.join(" ");

       for(n=0;n<number_of_atoms;n++){
       temp=" "+n+" ";
       comb1=saml2.split(temp);
       temp=atom_sorts[n]/100+"0"
       temp=" "+temp.substring(0,4)+" ";
       saml2=comb1.join(temp);
       }

     comb1=saml2.split("##");

// It is crucial that during the sort process, all paths have the same number of
// blanks in the beginning and for each separation. The number of blanks must not
// be determinant for the ranking order.

//----------- Sorting -------------
     comb1=comb1.sort();
//---------------------------------

// First each exact string (INCLUSIVE the second atom-ID at the end of each sting. The first
// atom-ID is the atom which is checked for chirality) must be present only once. The reason 
// is that multiplicates with respect to ONLY atom sorts and first atom-ID at the end of each
// sting (= everything except first neighbour atom) in their strings will be removed
// later so that chirality can be deduced by remaining differences. If the same string 
// have developed in two ways from one single neighbour atom to a atom, which is checked
// for chirality, only one of them should be erased in the first placed. However, one of
// them must be erased now, in order not to get both strings erased later as
// atom sorts multiplicate.

// dump already is =""
// Note that saml2 must have all path substrings separated with "##", not "#". In the later
// case, the first "#" of the second substring become erased when splitting in the first
// substring in saml2 which is = "#"+comb1[n]+"#".

     saml2="#"+saml2+"#";
       for(n=0;n<comb1.length;n++){
       tupp=saml2.split("#"+comb1[n]+"#");
       temp2=tupp.length-1+"  /";
       if(tupp.length<11) temp2="0"+temp2;
       tupp=comb1[n].split(" /");
       temp="#"+tupp[0]+temp2+tupp[1];
       if(dump.indexOf(temp)==-1) dump=dump+temp;
       }

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

     comb1=dump.split("#");
     saml2="";

// Now multiplicates can be removed. This is done by splitting the entire string collection
// with respective string pattern (EXCLUSIVE first neighbour atom which is noted last of the
// two atom-ID at the end of each string, and that which is checked for chirality), thus
// INCLUSIVE the absolute start atom, so that not branch (A) on possible chiral atom X should
// be checked as equal to branch (A) on possible chiral atom Y, and have both independent
// arms erased as dependent.
// comb1[0] is "" because "#" is first in dump

       for(n=1;n<comb1.length;n++){
       temp="#"+comb1[n].substring(0,comb1[n].lastIndexOf("//"));
       tupp=dump.split(temp);
       if(tupp.length<3) saml2=saml2+comb1[n]+"#";    // One split gives the length 2; less than 3
       }

   return saml2;

}
// ############################### end func ############################################