// ############################## START FUNC ############################################
// This is a rather complicated function which prepare an vector, comb1, to be interpretated in
// the function "determine_muliple_bonds". An formatted example comb1[n] looks like this, 5*2*1#7*2*0 which
// means that there are two paths, splittet by "#" which are sent to the actual atom. In the first case
// the path are sent from the neighbour atom 5 and have passed 2 atoms with -1 bonds (potential double bonded)
// and and 1 atom with -2 bonds (potential triple bonded).
// The counter for p=0 and up serves the same purpose as in many other functions, to traverse each path
// from its present atom variable to all neighbour atoms. All paths starts at the end atoms (ends list).
// But in this case there is an utter while-loop.
// If formations like =C< are met, new ends must be set, because double and triple bonds are determined
// by the number of -1 and -2 atoms that is passed (odd or even), in the function "determine_muliple_bonds".
// In the =C< formation, if the path is built from the upper corner to the right and sent to the lower corner
// to the right, the alternativity "odd,even,odd,even..." will be broken, because there are two single bonds
// two times running without an intermediate =. Therefore, new ends must be established at the position on
// C and at the upper and the lower corner, i.e. 3 new ends. Then, a new path series must be started.

function d_t_bonds(ends, mconn, atom_sorts, d_atoms, t_atoms, branchstop)
{

     var number_of_atoms=atom_sorts.length;
     var loopmax=parseInt(d_atoms.Span())+parseInt(t_atoms.Span());
     var comb1 = new Array(number_of_atoms);
     var comb2 = new Array(number_of_atoms);
       for(n=0;n<number_of_atoms;n++) comb1[n]="";
       for(n=0;n<number_of_atoms;n++) comb2[n]="";
     var tf=false;
     var au=new Array(0);
     var tupp=new Array(0);
     var atom_before=0;
     var n=0;
     var p=0;
     var m=0;
     var q=0;
     var temp="";
     var temp1="";
     var newends = new Array(number_of_atoms);
       for(n=0;n<number_of_atoms;n++) newends[n]=n;
     var newendsmarker=true;
     var memory = new List("empty", 0, atom_sorts); 

// This is he utter loop, which start new path series IF new ends have been set -> newendsmarker.
while(newendsmarker){

      for(n=0;n<number_of_atoms;n++){
      if(memory.Check(n)) newends[n]=n;
       if(newends[n]<0) ends.Add(n);
      comb1[n]="";
      comb2[n]="";
      memory.l[n]=false;
      }

newendsmarker=false;

for(p=0;p<loopmax;p++){
 for(n=0;n<number_of_atoms;n++){
 tf=ends.Check(n);
 tupp=comb1[n].split("#");       // The alternativity of odd/even does multiple strings less likely.
// -----------
if(tupp[0]!="" || tf){           // So the conjugated ens start new strings for each n
  for(m=0;m<tupp.length;m++){
     if(!tf){
     au=tupp[m].split("*");      // First part = last atom-ID, last part = number of steps gone
     atom_before=au[0];
     au[0]=n;
     if(d_atoms.Check(n)) au[1]=parseInt(au[1])+1;
     if(t_atoms.Check(n)) au[2]=parseInt(au[1])+1;
     tupp[m]=au.join("*");
     }
   for(q=0;q<mconn[n].length;q++){

// ^^^^^^marker^^^^^^^  // big if starts
     if((d_atoms.Check(mconn[n][q]) || t_atoms.Check(mconn[n][q])) && (newends[n] != newends[mconn[n][q]])){

     temp="";
     temp1="#"+comb2[mconn[n][q]];

       if(!tf && atom_before!=mconn[n][q]) temp=tupp[m]+"#";
       if(tf && d_atoms.Check(n)) temp=n+"*1*0#";
       if(tf && t_atoms.Check(n)) temp=n+"*0*1#";

// Below the condition (branchstop.Check(mconn[n][q]) && !odd_or_not(au[1])) answer to whether
// 1) ... the target neighbour is an branch stop (an =C< whith all (3) bond deficient neighbours)... AND
// 2) ... in the example "5*2*1" an even number of potential double bonded atoms have been left (passed).
// The answer in the example case is yes. The paranthesis is not needed.

// ***************** if-marker start *******************
       if(!tf && atom_before!=mconn[n][q] && (branchstop.Check(mconn[n][q]) && !odd_or_not(au[1]))){

if(-newends[mconn[n][q]]!=n){

// One path has already been received from right at the atom C in =C<. Whith this, the other
// is received and all atoms are set as ends. In the following while-loops, no path will be 
// developed from one end to another whith identical value newends[n]==newends[target neighbour].
// This you can see in the if-sentence "^^^^^^marker^^^^^^^".

        if(memory.Check(mconn[n][q])){
         newendsmarker=true;     
         newends[n]=newends[mconn[n][q]];
         newends[-newends[mconn[n][q]]]=newends[mconn[n][q]];
         memory.l[mconn[n][q]]=false;
        }
        else{

// This procedure seems overambitious, but can be good. If just one path from the right in =C<
// has been received at the branchstop (C), the value newends[C] neighbour is set no -No. for n.
// So paths can still develop in the opposit direction if there will be no further while loops,
// and the n end will not be set until confirmation with another path, the other from the right
// in =C<. This will be done above the else-sentence.

         newends[mconn[n][q]]=-n;
         memory.Add(mconn[n][q]);
        }
}

       }
// ****************** if-marker stop *******************

// The two fallowing if-sentences can be merged in one with &&, but that sentence will be very long.
// There may be some notorious condition, but this formulation makes it clear. 

       if(temp1.indexOf("#"+temp)==-1){
       if(tf || (atom_before!=mconn[n][q] && !tf && !(branchstop.Check(mconn[n][q]) && !odd_or_not(au[1])))){
       comb2[mconn[n][q]]=comb2[mconn[n][q]]+temp;
       }
       }

// So the format will be #atombefore*NpassedDoublebondatoms*NpassedTriplebondatoms#
     } // ^^^^^^if-marker^^^^^^^   big if ends. Look for the start for conditions
   }
  }
}
// -----------
 }
  for(n=0;n<number_of_atoms;n++){
  comb1[n]=comb2[n].substring(0,comb2[n].length-1);
  comb2[n]="";
  }
}

}  // end big, utter while-loop ends here

return comb1;
}
// ############################### end func ############################################