private BitSet[] findElementaryCycles( BitSet reachables ) {
			
		ArrayList<BitSet> elementaryCycles = new ArrayList<BitSet>();
		ArrayList<Integer> queue = new ArrayList<Integer>();
		queue.add(0);
		BitSet bitSet;
		int last, parent, son;
		
		for ( int source = dRun.length - 1; source >= 0; source-- )
			
			if ( reachables.get(source) ) {
				
				// we find all the elementary cycles with "source" as minimum
				bitSet = new BitSet();
				queue.add(source);
				
				while ( ! queue.isEmpty() ) {
					
					last = queue.get( queue.size() - 1 );
					
					if ( ! bitSet.get(last) && source <= last ) {
						// elementary cycle not founded
						bitSet.set(last);
						queue.add( succ0(last) );
						
					} else {
						
						if ( last == source )
							// elementary cycle founded with s as minimum! 
							elementaryCycles.add( (BitSet) bitSet.clone() );
						
						// (queue.length > 1) holds here
						// now we perform the backtracking
						queue.remove( queue.size() - 1 );
						son = last;
						parent = queue.get( queue.size() - 1 );
						
						while ( son == succ1( parent ) && queue.size() > 1 ) {
							queue.remove( queue.size() - 1 );
							bitSet.clear( parent );
							son = parent;
							parent = queue.get( queue.size() - 1 );
						}
						
						if ( son != succ1( parent ))
							// the search isn't ended
							// we insert in the queue the 1-successor of "parent"
							queue.add( succ1( parent ) );
						else 
							// queue.size() == 1
							// we founded all cycles with "source" as minimum
							queue.remove(0);
					}
				}
			}
		
		return elementaryCycles.toArray(new BitSet[elementaryCycles.size()]);
	}