docs: private Vector<Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>> createFuzzyCompleteNetwork(Constraint[] cns) {	
  		
  		if(subs != null){
  			if(subs.size() > 0) 
  				isSubGraph = true;
  		}
  		Constraint[] c = extractSubGraphCons(cns);
  		
  /*		if(isSubGraph){
  			
  			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
  			for (int i = 0; i < cns.length; i++) {
  				System.out.println("cns: " + cns[i]);	
  			}
  			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
  			for (int i = 0; i < subs.size(); i++) {
  				System.out.println("sb: " + subs.get(i));
  			}
  			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
  			for (int i = 0; i < c.length; i++) {
  				System.out.println("c: " + c[i]);	
  			}
  		} //Iran
  */
  		setNumVars(c);
  		
  		Vector<Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>> frelations = new Vector<Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>>();
  		
  		final class Coord {
  			public int x, y;
  			public Coord(int x, int y) { this.x = x; this.y = y; }
  			public boolean equals(Object o) {
  				if (!(o instanceof Coord)) return false;
  				Coord oc = (Coord)o;
  				return ((oc.x == x) && (oc.y == y));
  			}
  			public int hashCode() {
  				return (x*31)^y;
  			}
  		}
  		
  		HashMap<Coord, Vector<FuzzyAllenIntervalConstraint>> multiple = new HashMap<Coord, Vector<FuzzyAllenIntervalConstraint>>();
  		
  		FuzzyAllenIntervalConstraint[][] tmp = new FuzzyAllenIntervalConstraint[getNumVars()][getNumVars()];
  		
  		int row = 0 , col = 0;
  		for(int i = 0; i < c.length; i++){
  			if(!isSubGraph){
  				row = this.getID(c[i].getScope()[0]);
  				col = this.getID(c[i].getScope()[1]);
  			}
  			else{
  				row = (int)varIndex.get(c[i].getScope()[0].getID());
  				col = (int)varIndex.get(c[i].getScope()[1].getID());
  			}
  			if (tmp[row][col] == null)
  				tmp[row][col] = ((FuzzyAllenIntervalConstraint)c[i]);
  			else {
  				Coord coord = new Coord(row,col);
  				Vector<FuzzyAllenIntervalConstraint> vec = multiple.get(coord);
  				if (vec == null) {
  					vec = new Vector<FuzzyAllenIntervalConstraint>();
  					vec.add(tmp[row][col]);
  					multiple.put(coord, vec);
  				}
  				vec.add((FuzzyAllenIntervalConstraint)c[i]);
  			}
  		}
  		boolean isACrispCons = false;
  		for(int i = 0; i < tmp.length; i++){
  			Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>> con = new Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>(); 
  			for(int j = 0; j < tmp.length; j++){
  				if(crispCons != null && tmp[i][j] != null){
  					if(isACrispConstrint(tmp[i][j])) isACrispCons = true;
  				}
  				if(tmp[i][j] != null) {
  					//add poss (i,j)
  					/*
  					System.out.println("----------------------------------");
  					System.out.println("LOOKING AT " + tmpToConstraints.get(new Coords(i,j)) + ":\n" + (tmpToConstraints.get(new Coords(i,j))).getPossibilities());
  					System.out.println("----------------------------------");
  					*/
  					Coord coord = new Coord(i,j);
  					if (!multiple.containsKey(coord)) {
  						if(!isACrispCons)
  							con.add(tmp[i][j].getPossibilities());
  						else
  							con.add(tmp[i][j].makeCrispRel());
  					}
  					else {
  						if(!isACrispCons){
  							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).getPossibilities();
  							for (int h = 1; h < multiple.get(coord).size(); h++) {
  								updateRelation(poss, multiple.get(coord).get(h).getPossibilities());
  							}
  							con.add(poss);
  						}
  						else{
  							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).makeCrispRel();
  							for (int h = 1; h < multiple.get(coord).size(); h++) {
  								updateRelation(poss, multiple.get(coord).get(h).makeCrispRel());
  							}
  							con.add(poss);
  						}
  					}
  				}
  				else if (tmp[j][i] != null) {
  					//add inverse of (i,j)
  					/*
  					System.out.println("----------------------------------");
  					System.out.println("LOOKING AT (I) " + tmpToConstraints.get(new Coords(j,i)) + ":\n" + (tmpToConstraints.get(new Coords(j,i))).getInversePossibilities());
  					System.out.println("----------------------------------");
  					*/
  					Coord coord = new Coord(j,i);
  					if(!isACrispCons){
  						if (!multiple.containsKey(coord)) {
  							con.add(tmp[j][i].getInversePossibilities());
  						}
  						else {
  							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).getInversePossibilities();
  							for (int h = 1; h < multiple.get(coord).size(); h++) {
  								updateRelation(poss, multiple.get(coord).get(h).getInversePossibilities());
  							}
  							con.add(poss);
  						}
  					}
  					else{
  						if (!multiple.containsKey(coord)) {
  							con.add(tmp[j][i].getCrispInverse());
  						}
  						else {
  							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).getCrispInverse();
  							for (int h = 1; h < multiple.get(coord).size(); h++) {
  								updateRelation(poss, multiple.get(coord).get(h).getCrispInverse());
  							}
  							con.add(poss);
  						}
  					}
  				}
  				
  				//if no relation exists, add [all possibilities <-- 1.0]
  				else con.add(createAllFuzzyAllenRelation());
  			}
  			isACrispCons = false;
  			frelations.add(con);
  		}	
  		
  		return frelations;
  	}