docs: private boolean cCreate(Bounds[] in, int[] from, int[] to) {
  		long[] old_d = new long[in.length];
  		long[] old_D = new long[in.length];
  		boolean[] added = new boolean[in.length];
  		for (int i = 0; i < added.length; i++) added[i] = false;
  		boolean rollback = false;
  		int rollBackPoint = -1;
  
  		for (int i = 0; i < in.length; i++) {
  			//Conversion
  			long min = in[i].min;
  			long max = in[i].max;
  			if (in[i].max == APSPSolver.INF) max = H-O;
  			if (in[i].min == -APSPSolver.INF) min = -1 * (H - O);
  			in[i] = new Bounds(min,max);
  			//Checks
  			if (in[i].min > in[i].max) { rollback = true; rollBackPoint = i; break; /*return false;*/ }
  			if (from[i] == to[i]) { rollback = true; rollBackPoint = i; break; /*return false;*/ }
  
  			SimpleDistanceConstraint con = tPoints[from[i]].getOut(to[i]);
  			if (con != null) {
  				//Already existing edge
  				//check intersection between active con and new con
  				//added[i] = false;
  				if ( (con.getMinimum() > in[i].max) || (con.getMaximum() < in[i].min) ) { rollback = true; rollBackPoint = i; break; /*return false;*/ }
  				//Update active con
  				old_d[i] = con.getMinimum();
  				old_D[i] = con.getMaximum();
  				if (con.getMinimum() < in[i].min) con.setMinimum(in[i].min);
  				if (con.getMaximum() > in[i].max) con.setMaximum(in[i].max);
  			} 
  			else {          
  				//Non-existing arc
  				//Adding tentative constraint
  				added[i] = true;
  				con = new SimpleDistanceConstraint();
  				con.setFrom(this.getVariable(from[i]));
  				con.setTo(this.getVariable(to[i]));
  				con.setMinimum(in[i].min);
  				con.setMaximum(in[i].max);
  				con.addInterval(new Bounds(in[i].min,in[i].max));
  				tPoints[from[i]].setOut(to[i], con);
  			}
  		}
  
  		if (rollback) {
  			for (int i = rollBackPoint-1; i >= 0; i--) {
  				SimpleDistanceConstraint con = tPoints[from[i]].getOut(to[i]);
  				if (!added[i]) {
  					//Rollback in case of already existing edge
  					con.setMinimum(old_d[i]);
  					con.setMaximum(old_D[i]);
  				}
  				else {
  					//Rollback in case of new edge
  					con.removeInterval(in[i]);
  					tPoints[from[i]].setOut(to[i], null);
  				}
  			}
  			return false;
  		}
  
  		if (backupDMatrixSimple) saveDMatrixInternal();
  		if (!this.fromScratchDistanceMatrixComputation()) {
  			if (backupDMatrixSimple) restoreDMatrixInternal();
  			return false;
  		}
  		
  		//Ok update
  		for (int i = in.length-1; i >= 0; i--) {
  			if (!added[i]) {
  				SimpleDistanceConstraint con = tPoints[from[i]].getOut(to[i]);
  				con.addInterval(in[i]);
  			}
  		}
  
  		//[lb,ub] = [-di0,d0i]
  		for (int j = 0; j < MAX_USED+1; j++)
  			if (tPoints[j].isUsed() == true) {
  				tPoints[j].setLowerBound(sum(-distance[j][0],O));
  				tPoints[j].setUpperBound(sum(distance[0][j],O));
  			}
  		
  		return true;    
  	}