private void routeToTheRightGoingUpwards(Vertex2d start, Vertex2d end,
			Vertex2dFactory vertex2dFactory, List<Point2D> articulations) {

		//
		// For routing to the right and back up we will leave the start vertex from the right side
		// and enter the end vertex on the right side.   As the vertices get further apart, we will
		// space them further in towards the center.
		//

		int delta = start.rowIndex - end.rowIndex;
		int multiplier = EDGE_ENDPOINT_DISTANCE_MULTIPLIER;
		if (useSimpleRouting()) {
			multiplier = 1; // we allow edges to overlap with 'simple routing'
		}
		int distanceSpacing = delta * multiplier;

		// Condensing is when the graph will pull nodes closer together on the x axis to
		// reduce whitespace and make the entire graph easier to see.   In this case, update
		// the offset to avoid running into the moved vertices.

		// Condensing Note: we have guilty knowledge that our parent class my condense the
		// vertices and edges towards the center of the graph after we calculate positions.
		// To prevent the edges from moving to far behind the vertices, we will compensate a
		// bit for that effect using this offset value.   The getEdgeOffset() method is
		// updated for the condense factor.

		int exaggerationFactor = 1;
		if (isCondensedLayout()) {
			exaggerationFactor = 2; // determined by trial-and-error; can be made into an option
		}
		distanceSpacing *= exaggerationFactor;

		double x1 = start.getX();
		double y1 = start.getTop() + VERTEX_BORDER_THICKNESS;

		// spacing moves closer to center as the distance grows
		y1 += distanceSpacing;

		// restrict y from moving past the center
		double startCenterY = start.getY() - VERTEX_BORDER_THICKNESS;
		y1 = Math.min(y1, startCenterY);
		articulations.add(new Point2D.Double(x1, y1)); // point is hidden behind the vertex

		// Use the spacing to move the y value towards the top of the vertex.  Just like with
		// the x value, restrict the y to the range between the edge and the center.
		double startRightX = start.getRight();
		double x2 = startRightX + VERTEX_BORDER_THICKNESS; // start at the end

		// spacing moves closer to center as the distance grows
		x2 += distanceSpacing;

		double y2 = y1;
		articulations.add(new Point2D.Double(x2, y2));

		routeAroundColumnVertices(start, end, vertex2dFactory, articulations, x2);

		double x3 = x2;
		double y3 = end.getBottom() - VERTEX_BORDER_THICKNESS;

		// spacing moves closer to center as the distance grows
		y3 -= distanceSpacing;

		// restrict from moving back past the center
		double endYLimit = end.getY() + VERTEX_BORDER_THICKNESS;
		y3 = Math.max(y3, endYLimit);
		articulations.add(new Point2D.Double(x3, y3));

		double x4 = end.getX();
		double y4 = y3;
		articulations.add(new Point2D.Double(x4, y4)); // point is hidden behind the vertex
	}
An amount by which edges entering a vertex from the left are offset to avoid overlapping
Ghidra/Features/FunctionGraphDecompilerExtension/src/main/java/ghidra/app/plugin/core/functiongraph/graph/layout/DecompilerNestedLayout.java