// ############################## START FUNC ############################################
// This function follows all traces from possible chirality centra.
// There can be an seldomly occuring priority error concerning branches vs double bonds,
// which makes a simple fix in marker thjalp1 necessary for appropriate behaveor. The time
// lacks for me right now.

function chirality(poschir, threebranches, fourbranches, doubl_b, tripl_b, mconn, n_two_bond_atoms, atom_sorts, multibonds, chirmax)
{

     var number_of_atoms=atom_sorts.length;
     var string_vector_1 = new Array(number_of_atoms);
     var string_vector_2 = new Array(number_of_atoms);
       for(n=0;n<number_of_atoms;n++) string_vector_1[n]="";
       for(n=0;n<number_of_atoms;n++) string_vector_2[n]="";

     var collect_variable="";
     var thjalp1=0;
     var thjalp=0;
     var actual_direction="";
     var back_direction="";
     var temp_help_string="";
     var single_trace= new Array(0);
     var p=0;
     var n=0;
     var m=0;
     var q=0;
     var cleantemp;
     var prefix="";

      for(p=0;p<chirmax;p++){
       if(p>0 && string_vector_1.join("")=="") break;
       for(n=0;n<number_of_atoms;n++){
       single_trace=string_vector_1[n].split("#");
       thjalp1=1;

// A branched chain gives two strings. Earlier branching must be visible on these strings
// and assigned higher priority. Also, double bonds and triple bonds must give higher
// priority then a straight line, but lower then an ordinary branch.

       if(doubl_b.Check(n)) thjalp1=2;
       if(tripl_b.Check(n)) thjalp1=3;
       if(threebranches.Check(n)) thjalp1=4;
       if(fourbranches.Check(n)) thjalp1=5;
// The part multibonds[n]!="" below is for cis- trans-
      if(single_trace[0]!="" || (p==0 && (poschir.Check(n) || multibonds[n].indexOf("d")>-1))){
        for(m=0;m<single_trace.length;m++){
        thjalp=0;
         for(q=0;q<mconn[n].length;q++){
         actual_direction=" "+n+"->"+mconn[n][q]+" ";
         back_direction=" "+mconn[n][q]+"->"+n+" ";
// The string is never builded in a returning track, like "3->2 2->3"
// The last parenthesis below is for cis- trans-. Such atoms must not be tracked over the base C=C bond
         if(single_trace[m].indexOf(back_direction)==-1 && atom_sorts[mconn[n][q]]>1 && (p>0 || parseInt(multibonds[n].substring(2,multibonds[n].length))!=mconn[n][q])){
           if(single_trace[m].indexOf(actual_direction)==-1){
// In order to recognize cis- trans paths for extraction
           if(p==0 && multibonds[n]!="") single_trace[m]="x";
// To not fallow new rings when old are completed (the if-condition).
           if(single_trace[m].indexOf(" "+n+"-")==-1) string_vector_2[mconn[n][q]]=string_vector_2[mconn[n][q]]+single_trace[m]+actual_direction+"&"+thjalp1+" #";
           }
           else{
// The fallowed path in the ring complex a proper number of times
           cleantemp=single_trace[m];
           prefix="";
           if(cleantemp.charAt(0)=="x"){
           cleantemp=cleantemp.substring(1,cleantemp.length); // cis- trans-
           prefix="x";
           }
           collect_variable=collect_variable+prefix+string_mult(cleantemp,Math.abs(n_two_bond_atoms/5))+"#";
           }
         thjalp++;
         }
         }
// If the string was not built on and sent to any neighbour atom, it is deposited here instead.
// This is the case for end atoms like -CH3 or -Cl with their respective string history
        if(thjalp==0) collect_variable=collect_variable+single_trace[m]+"#";
        }
      }
       }
        for(n=0;n<number_of_atoms;n++){
        string_vector_1[n]=string_vector_2[n].substring(0,string_vector_2[n].length-1);
        string_vector_2[n]="";
        }
      }

// In contrary to the case for the similar procedur when calculating rings, here the 
// collected strings and the "unterminated" strings are put together in on and the
// same sting now, afterwords. string_vector_1[n] which does not contain a string should be 
// invisible. No "#####"- segments.
 
     for(n=0;n<string_vector_1.length;n++){
      if(string_vector_1[n]!="") string_vector_1[n]=string_vector_1[n]+"#";
     }

     temp_help_string = string_vector_1.join("");
// The last string_vector_1[n] has a "#" at the end which must be chopped
// However temp_help_string can be empty, so it is not ok to chop it directly.
     collect_variable=collect_variable + temp_help_string;
     collect_variable = collect_variable.substring(0, collect_variable.length-1);

     string_vector_1=collect_variable.split("#");

return string_vector_1;

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