// Copyright (c) 2016, 2017 Kiel University and others.
// Copyright (c) 2026 The elk-go Authors.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0.
//
// SPDX-License-Identifier: EPL-2.0

package p4nodes

import (
	
	

	
	
	
	basegraph 
	
	
)

const (
	networkSimplexEdgeWeightBase       = 4.0
	networkSimplexSmallEdgeWeight      = 0.1
	networkSimplexLongEdgeVsPathFactor = 2.0
	networkSimplexNodeSizeWeightStatic = 10000.0
	networkSimplexNodeSizeWeightFlex   = 1.0
	networkSimplexEpsilon              = 0.00001
)

// NetworkSimplexPlacer is the arena-backed port of ELK 0.8.1's
// NetworkSimplexPlacer. It converts vertical placement into an auxiliary
// layering problem and solves that problem with ELK's common network simplex.
type NetworkSimplexPlacer struct{}

func (*NetworkSimplexPlacer) (
	 *layered.LGraphArena,
	 layered.LGraphID,
) layered.ProcessorConfiguration {
	var  layered.ProcessorConfiguration
	if basegraph.Get(&.Graph().Properties, layered.GraphProperties)&
		layered.GraphPropertyExternalPorts != 0 {
		.AddBefore(layered.PhaseEdgeRouting, layered.HierarchicalPortPositionProcessor)
	}
	return 
}

func (*NetworkSimplexPlacer) ( *layered.LGraphArena,  layered.LGraphID) error {
	 := networkSimplexPlacement{
		arena:              ,
		graphID:            ,
		portMap:            make(map[layered.LPortID]networksimplex.NodeID),
		flexibleWhereSpace: make(map[networksimplex.EdgeID]struct{}),
	}
	.prepare()
	if  := .buildInitialAuxiliaryGraph();  != nil {
		return 
	}
	.insertNorthSouthAuxiliaryEdges()
	if  := .insertInLayerAuxiliaryEdges();  != nil {
		return 
	}
	if basegraph.Get(&.Graph().Properties, layered.FavorStraightEdges) {
		.preferStraightEdges()
	}
	.network.MakeConnected()
	 := basegraph.Get(&.Graph().Properties, layered.Thoroughness) *
		len(.network.Nodes)
	networksimplex.ForGraph(.network).
		WithIterationLimit().
		WithBalancing(false).
		Execute()
	if len(.flexibleWhereSpace) != 0 {
		.insertFlexibleWhereSpaceAuxiliaryEdges()
		for  := range .flexibleWhereSpace {
			.network.Edge().Weight = networkSimplexNodeSizeWeightFlex
		}
		networksimplex.ForGraph(.network).
			WithIterationLimit().
			WithBalancing(false).
			Execute()
	}
	if basegraph.Get(&.Graph().Properties, layered.FavorStraightEdges) {
		.postProcessTwoPaths()
	}
	.applyPositions()
	return nil
}

type networkSimplexPlacement struct {
	arena   *layered.LGraphArena
	graphID layered.LGraphID
	network *networksimplex.Graph

	nodeReps []networkSimplexNodeRep
	edgeReps []networkSimplexEdgeRep
	portMap  map[layered.LPortID]networksimplex.NodeID

	nodeState []int
	twoPaths  [][]layered.LEdgeID
	crossing  []bool

	flexibleWhereSpace map[networksimplex.EdgeID]struct{}
}

type networkSimplexNodeRep struct {
	origin     layered.LNodeID
	head       networksimplex.NodeID
	tail       networksimplex.NodeID
	isFlexible bool
}

type networkSimplexEdgeRep struct {
	origin layered.LEdgeID
	left   networksimplex.EdgeID
	right  networksimplex.EdgeID
}

func ( networkSimplexEdgeRep) ( *networksimplex.Graph) int {
	,  := .Edge(.left), .Edge(.right)
	return (.Node(.Target).Layer - .Delta) -
		(.Node(.Target).Layer - .Delta)
}

func ( networkSimplexEdgeRep) ( *networksimplex.Graph) bool {
	return .notStraightBy() == 0
}

func ( *networkSimplexPlacement) () {
	.network = networksimplex.NewGraph()
	,  := 0, 0
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			 := .arena.Node()
			.ID = 
			++
			for ,  := range .arena.NodeOutgoingEdges() {
				.arena.Edge().ID = 
				++
			}

			 := .isFlexibleNode()
			for ,  := range .Ports {
				 := .arena.Port()
				if  && .Anchor.Y != math.Floor(.Anchor.Y) {
					 := .Anchor.Y - float64(javacompat.MathRoundDouble(.Anchor.Y))
					.Anchor.Y -= 
				}
				 := .Position.Y + .Anchor.Y
				if  != math.Floor() {
					 :=  - float64(javacompat.MathRoundDouble())
					.Position.Y -= 
				}
			}
		}
	}
	.nodeReps = make([]networkSimplexNodeRep, )
	.edgeReps = make([]networkSimplexEdgeRep, )
}

func ( *networkSimplexPlacement) () error {
	for ,  := range .arena.Graph(.graphID).Layers {
		.transformLayer()
	}
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			for ,  := range .arena.NodeOutgoingEdges() {
				if .isHandledEdge() {
					if  := .transformEdge();  != nil {
						return 
					}
				}
			}
		}
	}
	return nil
}

func ( *networkSimplexPlacement) ( layered.LayerID) {
	var  *networkSimplexNodeRep
	for ,  := range .arena.Layer().Nodes {
		var  networkSimplexNodeRep
		if .isFlexibleNode() {
			 = .transformFixedOrderNode()
		} else {
			 = .transformFixedPositionNode()
		}
		.nodeReps[.arena.Node().ID] = 
		if  != nil {
			 := .arena.Node(.origin)
			 := .arena.Node()
			 := .Margin.Bottom +
				layered.VerticalSpacing(.arena, .origin, ) +
				.Margin.Top
			if !.isFlexible {
				 += .Size.Y
			}
			.network.AddEdge(.tail, .head, 0, int(math.Ceil()))
		}
		 := 
		 = &
	}
}

func ( *networkSimplexPlacement) (
	 layered.LNodeID,
) networkSimplexNodeRep {
	 := .network.AddNode()
	.network.Node().Origin = 
	for ,  := range .arena.Node().Ports {
		 := .arena.Port().Side
		if  == layered.EastSide ||  == layered.WestSide {
			.portMap[] = 
		}
	}
	return networkSimplexNodeRep{origin: , head: , tail: }
}

func ( *networkSimplexPlacement) (
	 layered.LNodeID,
) networkSimplexNodeRep {
	 := .network.AddNode()
	 := .network.AddNode()
	.network.Node().Origin = 
	.network.Node().Origin = 
	 := networkSimplexNodeRep{origin: , head: , tail: , isFlexible: true}

	 := .nodeFlexibility()
	 := networkSimplexNodeSizeWeightStatic
	if .IsFlexibleSize() {
		 = networkSimplexNodeSizeWeightFlex
	}
	 := .network.AddEdge(
		, , , int(math.Ceil(.arena.Node().Size.Y)),
	)
	if  == layered.NodeFlexibilitySizeWhereSpacePermits {
		.flexibleWhereSpace[] = struct{}{}
	}

	 := append([]layered.LPortID(nil), .arena.NodePortSideView(, layered.WestSide)...)
	for ,  := 0, len()-1;  < ; ,  = +1, -1 {
		[], [] = [], []
	}
	.transformPorts(, )
	.transformPorts(.arena.NodePortSideView(, layered.EastSide), )
	return 
}

func ( *networkSimplexPlacement) (
	 []layered.LPortID,
	 networkSimplexNodeRep,
) {
	if len() == 0 {
		return
	}
	 := layered.IndividualOrDefault(
		.arena, .origin, &layered.SpacingPortPort,
	)
	 := .portSurrounding(.origin)
	 := .head
	var  *layered.LPortID
	for ,  := range  {
		 := .Top
		if  != nil {
			 =  + .arena.Port(*).Size.Y
		}
		 := .network.AddNode()
		.network.Node().Origin = 
		.portMap[] = 
		.network.AddEdge(, , 0, int(math.Ceil()))
		 := 
		 = &
		 = 
	}
	.network.AddEdge(
		,
		.tail,
		0,
		int(math.Ceil(.Bottom+.arena.Port(*).Size.Y)),
	)
}

func ( *networkSimplexPlacement) ( layered.LEdgeID) error {
	 := .arena.Edge()
	 := .network.AddNode()
	,  := *.Source, *.Target
	,  := .portMap[]
	,  := .portMap[]
	if ! || ! {
		return errors.New("NEdge must have a source and target NNode specified")
	}
	 := .nodeReps[.arena.Node(.arena.EdgeSourceNode()).ID]
	 := .nodeReps[.arena.Node(.arena.EdgeTargetNode()).ID]
	 := .arena.Port().Anchor.Y
	 := .arena.Port().Anchor.Y
	if !.isFlexible {
		 += .arena.Port().Position.Y
	}
	if !.isFlexible {
		 += .arena.Port().Position.Y
	}
	 := int(math.Max(0, -))
	 := int(math.Max(0, -))
	 := .edgeWeight()
	 := .network.AddEdge(, , , )
	 := .network.AddEdge(, , , )
	.network.Edge().Origin = 
	.network.Edge().Origin = 
	.edgeReps[.ID] = networkSimplexEdgeRep{origin: , left: , right: }
	return nil
}

func ( *networkSimplexPlacement) () error {
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			if .arena.Node().Type != layered.NormalNode {
				continue
			}
			for ,  := range .arena.NodeConnectedEdges() {
				if !.arena.EdgeIsInLayer() {
					continue
				}
				 := .arena.EdgeSourceNode()
				 := .arena.EdgeTargetNode()
				 := .arena.Node().Type != layered.NormalNode
				,  := *.arena.Edge().Source, 
				if  {
					,  = *.arena.Edge().Target, 
				}
				,  := .portMap[]
				if ! {
					return errors.New("NEdge must have a source and target NNode specified")
				}
				 := .nodeReps[.arena.Node().ID].head
				if .arena.NodeIndexInLayer(*.arena.Port().Node) <
					.arena.NodeIndexInLayer() {
					.network.AddEdge(, , networkSimplexEdgeWeightBase, 0)
				} else {
					.network.AddEdge(, , networkSimplexEdgeWeightBase, 0)
				}
			}
		}
	}
	return nil
}

func ( *networkSimplexPlacement) () {
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			for ,  := range .arena.NodePortSideView(, layered.SouthSide) {
				if ,  := basegraph.TryGet(&.arena.Port().Properties, layered.PortDummy);  {
					.network.AddEdge(
						.nodeReps[.arena.Node().ID].tail,
						.nodeReps[.arena.Node().ID].head,
						networkSimplexSmallEdgeWeight,
						0,
					)
				}
			}
			for ,  := range .arena.NodePortSideView(, layered.NorthSide) {
				if ,  := basegraph.TryGet(&.arena.Port().Properties, layered.PortDummy);  {
					.network.AddEdge(
						.nodeReps[.arena.Node().ID].tail,
						.nodeReps[.arena.Node().ID].head,
						networkSimplexSmallEdgeWeight,
						0,
					)
				}
			}
		}
	}
}

func ( *networkSimplexPlacement) () {
	,  := math.MaxInt, math.MinInt
	for ,  := range .network.Nodes {
		 := .network.Node().Layer
		 = min(, )
		 = max(, )
	}
	 :=  - 
	 := .network.AddNode()
	 := .network.AddNode()
	.network.AddEdge(
		, , networkSimplexNodeSizeWeightStatic*2, ,
	)
	for ,  := range .nodeReps {
		 := .arena.Node(.origin)
		if .Type != layered.NormalNode || len(.Ports) <= 1 {
			continue
		}
		.network.AddEdge(, .tail, 0,
			.network.Node(.tail).Layer-)
		.network.AddEdge(.head, , 0,
			-.network.Node(.head).Layer)
	}
}

func ( *networkSimplexPlacement) () {
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			 := .nodeReps[.arena.Node().ID]
			 := float64(.network.Node(.head).Layer)
			 := float64(.network.Node(.tail).Layer)
			 := .arena.Node()
			.Position.Y = 
			 :=  -  - .Size.Y
			 := .nodeFlexibility()
			if .isFlexible && .IsFlexibleSizeWhereSpacePermits() {
				.Size.Y += 
			}
			if .isFlexible && .IsFlexiblePorts() {
				for ,  := range .Ports {
					 := .arena.Port()
					if .Side == layered.EastSide || .Side == layered.WestSide {
						.Position.Y = float64(.network.Node(.portMap[]).Layer) - 
					}
				}
				.adjustLabelsAndSouthPorts(, , )
			}
		}
	}
}

func ( *networkSimplexPlacement) ( layered.LEdgeID) float64 {
	 := basegraph.Get(&.arena.Edge().Properties, layered.PriorityStraightness)
	if  < 1 {
		 = 1
	}
	return float64() * .edgeTypeWeight(
		.arena.Node(.arena.EdgeSourceNode()).Type,
		.arena.Node(.arena.EdgeTargetNode()).Type,
	)
}

func (*networkSimplexPlacement) (,  layered.NodeType) float64 {
	if  == layered.NormalNode &&  == layered.NormalNode {
		return networkSimplexEdgeWeightBase
	}
	if  == layered.NormalNode ||  == layered.NormalNode {
		return 2 * networkSimplexEdgeWeightBase
	}
	return 8 * networkSimplexEdgeWeightBase
}

func ( *networkSimplexPlacement) ( layered.LEdgeID) bool {
	return !.arena.EdgeIsSelfLoop() && !.arena.EdgeIsInLayer()
}

func ( *networkSimplexPlacement) ( layered.LNodeID) layered.NodeFlexibility {
	if ,  := basegraph.TryGet(
		&.arena.Node().Properties, layered.NetworkSimplexNodeFlexibility,
	);  {
		return 
	}
	return basegraph.Get(
		&.arena.Graph(.arena.NodeGraph()).Properties,
		layered.NetworkSimplexNodeFlexibilityDefault,
	)
}

func ( *networkSimplexPlacement) ( layered.LNodeID) bool {
	 := .arena.Node()
	if .Type != layered.NormalNode || len(.Ports) <= 1 {
		return false
	}
	 := basegraph.Get(&.Properties, layered.PortConstraintsOption)
	// The Go LabelAndNodeSizeProcessor records the original constraint before
	// materializing FIXED_POS. ELK's adapter fixes coordinates without replacing
	// the property, so consult the saved value to preserve the Java decision.
	if ,  := basegraph.TryGet(&.Properties, layered.OriginalPortConstraints);  {
		 = 
	}
	if .IsPositionFixed() {
		return false
	}
	 := .nodeFlexibility()
	if  == layered.NodeFlexibilityNone {
		return false
	}
	if !.IsFlexibleSizeWhereSpacePermits() {
		 := layered.IndividualOrDefault(.arena, , &layered.SpacingPortPort)
		 := .portSurrounding()
		for ,  := range []layered.PortSide{layered.WestSide, layered.EastSide} {
			 := .arena.NodePortSideView(, )
			 := .Top + .Bottom + float64(len()-1)*
			if  > .Size.Y {
				return false
			}
		}
	}
	return true
}

func ( *networkSimplexPlacement) ( layered.LNodeID) geometry.Spacing {
	if ,  := basegraph.TryGet(
		&.arena.Node().Properties, layered.SpacingIndividual,
	);  {
		if ,  := basegraph.TryGet(
			&.Properties, layered.SpacingPortsSurrounding,
		);  {
			return 
		}
	}
	return basegraph.Get(
		&.arena.Graph(.arena.NodeGraph()).Properties,
		layered.SpacingPortsSurrounding,
	)
}

func ( *networkSimplexPlacement) (
	 layered.LNodeID,
	 float64,
	 layered.NodeFlexibility,
) {
	 := .arena.Node()
	 := basegraph.Get(&.Properties, nodespacing.NodeLabelsPlacement)
	for ,  := range .Labels {
		if containsString(, "V_BOTTOM") {
			.arena.Label().Position.Y += 
		} else if containsString(, "V_CENTER") {
			.arena.Label().Position.Y +=  / 2
		}
	}
	if .IsFlexibleSizeWhereSpacePermits() {
		for ,  := range .arena.NodePortSideView(, layered.SouthSide) {
			.arena.Port().Position.Y += 
		}
	}
}

func containsString( []string,  string) bool {
	for ,  := range  {
		if  ==  {
			return true
		}
	}
	return false
}

const (
	networkSimplexVisited  = -1
	networkSimplexOther    = 0
	networkSimplexJunction = 2
)

func ( *networkSimplexPlacement) () {
	.nodeState = make([]int, len(.nodeReps))
	.twoPaths = nil
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			.nodeState[.arena.Node().ID] = .nodeStraighteningState()
		}
	}
	.markEdgeCrossings()
	for ,  := range .identifyPaths() {
		if len() <= 1 {
			continue
		}
		if len() == 2 {
			 = .orderTwoPath()
			 := .arena.EdgeTargetNode([0])
			if !.isFlexibleNode() {
				.twoPaths = append(.twoPaths, )
			}
			continue
		}
		if .pathContainsLongEdgeDummy() ||
			.pathContainsFlexibleResizableNode() {
			continue
		}
		for ,  := range  {
			 := &.edgeReps[.arena.Edge().ID]
			 := .edgeTypeWeight(layered.LongEdgeNode, layered.LongEdgeNode)
			if  == 0 ||  == len()-1 {
				 = .edgeTypeWeight(layered.NormalNode, layered.LongEdgeNode)
			}
			 *= networkSimplexLongEdgeVsPathFactor
			 := .network.Edge(.left)
			.Weight = math.Max(.Weight, .Weight+(-.Weight))
			 := .network.Edge(.right)
			.Weight = math.Max(.Weight, .Weight+(-.Weight))
		}
	}
}

func ( *networkSimplexPlacement) () {
	 := append([][]layered.LEdgeID(nil), .twoPaths...)
	 := make([][]layered.LEdgeID, 0)
	for len() != 0 {
		 := [0]
		 = [1:]
		if .improveTwoPath(, true) {
			 = append(, )
		}
	}
	for len() != 0 {
		 := len() - 1
		.improveTwoPath([], false)
		 = [:]
	}
}

func ( *networkSimplexPlacement) (
	 []layered.LEdgeID,
	 bool,
) bool {
	 := .edgeReps[.arena.Edge([0]).ID]
	 := .edgeReps[.arena.Edge([1]).ID]
	if .isStraight(.network) && .isStraight(.network) {
		return false
	}
	 := .network.Node(.network.Edge(.right).Target).Origin
	,  := .(layered.LNodeID)
	if ! {
		return false
	}
	 := &.nodeReps[.arena.Node().ID]
	 := *.arena.Node().Layer
	 := .arena.Layer().Nodes
	 := .arena.NodeIndexInLayer()
	 := math.Inf(1)
	if  > 0 {
		 := [-1]
		 := .nodeReps[.arena.Node().ID]
		 := math.Ceil(layered.VerticalSpacing(.arena, , ))
		 = float64(.network.Node(.head).Layer) -
			.arena.Node().Margin.Top -
			(float64(.network.Node(.head).Layer) +
				.arena.Node().Size.Y + .arena.Node().Margin.Bottom) -
			
	}
	 := math.Inf(1)
	if  < len()-1 {
		 := [+1]
		 := .nodeReps[.arena.Node().ID]
		 := math.Ceil(layered.VerticalSpacing(.arena, , ))
		 = float64(.network.Node(.head).Layer) -
			.arena.Node().Margin.Top -
			(float64(.network.Node(.head).Layer) +
				.arena.Node().Size.Y + .arena.Node().Margin.Bottom) -
			
	}
	if  && fuzzyEqual(, , networkSimplexEpsilon) {
		return true
	}

	 := .networkEdgeLength(.left)
	 := -.networkEdgeLength(.right)
	 := -.networkEdgeLength(.left)
	 := .networkEdgeLength(.right)
	 := .notStraightBy(.network)
	 := .notStraightBy(.network)
	 :=  > 0 &&  < 0
	 :=  < 0 &&  > 0
	 := .network.Edge(.left)
	 := .network.Edge(.right)
	 := .network.Edge(.left)
	 := .network.Edge(.right)
	 := .network.Node(.Target).Layer+.Delta <
		.network.Node(.Target).Layer+.Delta
	 := .network.Node(.Target).Layer+.Delta >
		.network.Node(.Target).Layer+.Delta
	 := 0
	if ! && ! {
		if  {
			if +float64() > 0 {
				 = 
			} else if -float64() > 0 {
				 = 
			}
		} else if  {
			if +float64() > 0 {
				 = 
			} else if -float64() > 0 {
				 = 
			}
		}
	}
	.network.Node(.head).Layer += 
	if .isFlexible {
		.network.Node(.tail).Layer += 
	}
	return false
}

func ( *networkSimplexPlacement) ( networksimplex.EdgeID) int {
	 := .network.Edge()
	 := .network.Node(.Source).Layer - .network.Node(.Target).Layer
	if  < 0 {
		 = -
	}
	return  - .Delta
}

func ( *networkSimplexPlacement) () [][]layered.LEdgeID {
	 := make([][]layered.LEdgeID, 0)
	for ,  := range .arena.Graph(.graphID).Layers {
		for ,  := range .arena.Layer().Nodes {
			if .nodeState[.arena.Node().ID] != networkSimplexJunction {
				continue
			}
			for ,  := range .arena.NodeConnectedEdges() {
				if !.isHandledEdge() {
					continue
				}
				 := .followPath(, , nil)
				if len() > 1 {
					 = append(, )
				}
			}
		}
	}
	return 
}

func ( *networkSimplexPlacement) (
	 layered.LEdgeID,
	 layered.LNodeID,
	 []layered.LEdgeID,
) []layered.LEdgeID {
	 := .arena.EdgeOtherNode(, )
	 = append(, )
	 := .nodeState[.arena.Node().ID]
	if  == networkSimplexVisited ||  == networkSimplexJunction ||
		.crossing[.arena.Edge().ID] {
		return 
	}
	.nodeState[.arena.Node().ID] = networkSimplexVisited
	for ,  := range .arena.NodeConnectedEdges() {
		if  ==  || !.isHandledEdge() {
			continue
		}
		return .(, , )
	}
	return 
}

func ( *networkSimplexPlacement) ( layered.LNodeID) int {
	,  := 0, 0
	for ,  := range .arena.Node().Ports {
		for ,  := range .arena.Port().IncomingEdges {
			if !.arena.EdgeIsSelfLoop() {
				++
			}
		}
		for ,  := range .arena.Port().OutgoingEdges {
			if !.arena.EdgeIsSelfLoop() {
				++
			}
		}
		if  > 1 ||  > 1 {
			return networkSimplexJunction
		}
	}
	if + == 1 {
		return networkSimplexJunction
	}
	return networkSimplexOther
}

func ( *networkSimplexPlacement) () {
	.crossing = make([]bool, len(.edgeReps))
	 := .arena.Graph(.graphID).Layers
	for  := 0; +1 < len(); ++ {
		.markCrossingsBetween([], [+1])
	}
}

func ( *networkSimplexPlacement) (
	,  layered.LayerID,
) {
	 := make([]layered.LEdgeID, 0)
	for ,  := range .arena.Layer().Nodes {
		for ,  := range .arena.NodePortSideView(, layered.EastSide) {
			for ,  := range .arena.Port().OutgoingEdges {
				if .arena.EdgeIsInLayer() || .arena.EdgeIsSelfLoop() ||
					.arena.Node(.arena.EdgeTargetNode()).Layer == nil ||
					*.arena.Node(.arena.EdgeTargetNode()).Layer !=  {
					continue
				}
				 = append(, )
			}
		}
	}
	 := .arena.Layer().Nodes
	for  := len() - 1;  >= 0; -- {
		for ,  := range .arena.NodePortSideView([], layered.WestSide) {
			for ,  := range .arena.Port().IncomingEdges {
				if .arena.EdgeIsInLayer() || .arena.EdgeIsSelfLoop() ||
					.arena.Node(.arena.EdgeSourceNode()).Layer == nil ||
					*.arena.Node(.arena.EdgeSourceNode()).Layer !=  {
					continue
				}
				if len() == 0 {
					continue
				}
				 := len() - 1
				 := []
				for  !=  &&  > 0 {
					.crossing[.arena.Edge().ID] = true
					.crossing[.arena.Edge().ID] = true
					--
					 = []
				}
				// This deliberately retains ELK's ListIterator.hasPrevious guard:
				// an edge at index zero is not removed.
				if  > 0 {
					copy([:], [+1:])
					 = [:len()-1]
				}
			}
		}
	}
}

func ( *networkSimplexPlacement) ( []layered.LEdgeID) bool {
	if len() == 0 {
		return false
	}
	if .arena.Node(.arena.EdgeSourceNode([0])).Type == layered.LongEdgeNode {
		return true
	}
	for ,  := range  {
		if .arena.Node(.arena.EdgeTargetNode()).Type == layered.LongEdgeNode {
			return true
		}
	}
	return false
}

func ( *networkSimplexPlacement) (
	 []layered.LEdgeID,
) bool {
	if len() == 0 {
		return false
	}
	if .nodeFlexibility(.arena.EdgeSourceNode([0])).IsFlexibleSizeWhereSpacePermits() {
		return true
	}
	for ,  := range  {
		if .nodeFlexibility(.arena.EdgeTargetNode()).IsFlexibleSizeWhereSpacePermits() {
			return true
		}
	}
	return false
}

func ( *networkSimplexPlacement) ( []layered.LEdgeID) []layered.LEdgeID {
	if len() != 2 {
		panic("network simplex: only a two-path may be ordered")
	}
	if .arena.EdgeTargetNode([0]) != .arena.EdgeSourceNode([1]) {
		[0], [1] = [1], [0]
	}
	return 
}

func fuzzyEqual(, ,  float64) bool {
	return  ==  || math.Abs(-) <= 
}