class Traverser extends BfsTraverser<BetweennessNode> {

        private Map<Id, MutableFloat> globalBetweennesses;

        private Traverser(UserJob<Object> job) {
            super(job);
        }

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

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

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

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

        @Override
        protected void backtrack(Id startVertex, Id currentVertex,
                                 Map<Id, BetweennessNode> localNodes) {
            if (startVertex.equals(currentVertex)) {
                return;
            }
            MutableFloat betweenness = this.globalBetweennesses.get(
                    currentVertex);
            if (betweenness == null) {
                betweenness = new MutableFloat(0.0F);
                this.globalBetweennesses.put(currentVertex, betweenness);
            }
            BetweennessNode node = localNodes.get(currentVertex);
            betweenness.add(node.betweenness());

            // Contribute to parents
            for (Id v : node.parents()) {
                BetweennessNode parentNode = localNodes.get(v);
                parentNode.increaseBetweenness(node);
            }
        }
    }

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

            this.globalBetweennesses = new HashMap<>();
            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.globalBetweennesses.putIfAbsent(startVertex,
                                                     new MutableFloat());
                this.compute(startVertex, direction, edgeLabelId,
                             degree, depth);
            }
            if (topN > 0L || topN == NO_LIMIT) {
                return HugeTraverser.topN(this.globalBetweennesses,
                                          true, topN);
            } else {
                return this.globalBetweennesses;
            }
        
<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