class Traverser extends BfsTraverser<StressNode> {

        private final Map<Id, MutableLong> globalStresses;

        private Traverser(UserJob<Object> job) {
            super(job);
            this.globalStresses = new HashMap<>();
        }

        private Object stressCentrality(Directions direction,
                                        String label,
                                        int depth,
                                        long degree,
                                        long sample,
                                        String sourceLabel,
                                        long sourceSample,
                                        String sourceCLabel,
                                        long topN) {<FILL_FUNCTION_BODY>}

        @Override
        protected StressNode createStartNode() {
            return new StressNode(1, 0);
        }

        @Override
        protected StressNode createNode(StressNode parentNode) {
            return new StressNode(parentNode);
        }

        @Override
        protected void meetNode(Id currentVertex, StressNode currentNode,
                                Id parentVertex, StressNode parentNode,
                                boolean firstTime) {
            currentNode.addParentNode(parentNode, parentVertex);
        }

        @Override
        protected void backtrack(Id startVertex, Id currentVertex,
                                 Map<Id, StressNode> localNodes) {
            if (startVertex.equals(currentVertex)) {
                return;
            }
            StressNode currentNode = localNodes.get(currentVertex);

            // Add local stresses to global stresses
            MutableLong stress = this.globalStresses.get(currentVertex);
            if (stress == null) {
                stress = new MutableLong(0L);
                this.globalStresses.put(currentVertex, stress);
            }
            stress.add(currentNode.stress());

            // Contribute to parents
            for (Id v : currentNode.parents()) {
                StressNode parentNode = localNodes.get(v);
                parentNode.increaseStress(currentNode);
            }
        }
    }

            assert depth > 0;
            assert degree > 0L || degree == NO_LIMIT;
            assert topN >= 0L || topN == NO_LIMIT;

            Id edgeLabelId = this.getEdgeLabelIdOrNull(label);

            // TODO: sample the startVertices
            Iterator<Vertex> startVertices = this.vertices(sourceLabel,
                                                           sourceCLabel,
                                                           Query.NO_LIMIT);
            while (startVertices.hasNext()) {
                Id startVertex = ((HugeVertex) startVertices.next()).id();
                this.globalStresses.putIfAbsent(startVertex, new MutableLong(0L));
                this.compute(startVertex, direction, edgeLabelId,
                             degree, depth);
            }
            if (topN > 0L || topN == NO_LIMIT) {
                return HugeTraverser.topN(this.globalStresses, true, topN);
            } else {
                return this.globalStresses;
            }
        
<methods>public non-sealed void <init>() ,public java.lang.String category() ,public void checkParameters(Map<java.lang.String,java.lang.Object>) <variables>private static final Logger LOG