public override int Next(int x)
        {
            if (min != NULL_KEY && x < min)
            {
                return(min);
            }

            int x_highest = highest(x);

            //--- sigmaScopes common for all sigmaNode scopes ---->
            Scope sigmaScopesItem;


            vEBTreeNode nodeTypeInfo   = levels[level].Scopes[nodeId];
            int         sigmaScopesKey =
                nodeTypeInfo.IndexOffset
                + nodeTypeInfo.NodeSize
                * registryId
                + x_highest;
            //<-----sigmaNode key --- global

            int maximumLow = NULL_KEY;

            if (sigmaScopes.TryGet(sigmaScopesKey, out sigmaScopesItem))
            {
                maximumLow = sigmaScopesItem.IndexMax;
            }

            if (maximumLow != NULL_KEY && lowest(x) < maximumLow)
            {
                int _offset = sigmaScopesItem.Next(lowest(x));
                return(index(x_highest, _offset));
            }

            if (sigmaNode == null)
            {
                return(NULL_KEY);
            }

            //======================//
            //from sigmaNode part
            //======================//

            int successorCluster = sigmaNode.Next(x_highest);

            if (successorCluster == NULL_KEY)
            {
                return(NULL_KEY);
            }

            //--- sigmaScopes common for all sigmaNode scopes ---->
            sigmaScopesKey = nodeTypeInfo.IndexOffset + nodeTypeInfo.NodeSize * registryId + successorCluster;
            //<-----sigmaNode key --- global

            sigmaScopes.TryGet(sigmaScopesKey, out sigmaScopesItem);
            int offset = sigmaScopesItem.IndexMin;

            return(index(successorCluster, offset));
        }    // used only for sigmaNode
        public override bool Remove(int x)
        {
            if (min == max)
            {
                if (min != x)
                {
                    return(true);
                }
                min       = NULL_KEY;
                max       = NULL_KEY;
                sigmaNode = null;
                return(true);
            }

            //--- sigmaScopes common for all sigmaNode scopes ---->
            Scope       sigmaScopesItem;
            vEBTreeNode nodeTypeInfo = levels[level].Scopes[nodeId];;
            int         sigmaScopesKey;
            //<-----sigmaNode key --- global
            int x_highest;

            if (min == x)
            {
                int first = sigmaNode.IndexMin;

                //--- sigmaScopes common for all sigmaNode scopes ---->
                sigmaScopesKey = nodeTypeInfo.IndexOffset + nodeTypeInfo.NodeSize * registryId + first;
                sigmaScopes.TryGet(sigmaScopesKey, out sigmaScopesItem);
                x = index(first, sigmaScopesItem.IndexMin);
                //<-----sigmaNode key --- global
                min = x;
            }

            x_highest = highest(x);
            //--- sigmaScopes common for all sigmaNode scopes ---->
            sigmaScopesKey = nodeTypeInfo.IndexOffset + nodeTypeInfo.NodeSize * registryId + x_highest;
            if (!sigmaScopes.TryGet(sigmaScopesKey, out sigmaScopesItem))
            {
                return(false);
            }
            sigmaScopesItem.Remove(lowest(x));
            //<-----sigmaNode key --- global

            if (sigmaScopesItem.IndexMin == NULL_KEY)
            {
                //--- sigmaScopes common for all sigmaNode scopes ---->
                sigmaScopes.Remove(sigmaScopesKey);
                //<-----sigmaNode key --- global

                sigmaNode.Remove(highest(x));

                if (x == max)
                {
                    int sigmaNodeMaximum = sigmaNode.IndexMax;

                    if (sigmaNodeMaximum == NULL_KEY)
                    {
                        max       = min;
                        sigmaNode = null;
                    }
                    else
                    {
                        //--- sigmaScopes common for all sigmaNode scopes ---->
                        sigmaScopesKey = nodeTypeInfo.IndexOffset + nodeTypeInfo.NodeSize * registryId + sigmaNodeMaximum;
                        sigmaScopes.TryGet(sigmaScopesKey, out sigmaScopesItem);
                        int maximumKey = sigmaScopesItem.IndexMax;
                        //<-----sigmaNode key --- global

                        max = index(sigmaNodeMaximum, maximumKey);
                    }
                }
            }
            else if (x == max)
            {
                //--- sigmaScopes common for all sigmaNode scopes ---->
                sigmaScopesKey = nodeTypeInfo.IndexOffset + nodeTypeInfo.NodeSize * registryId + highest(x);
                sigmaScopes.TryGet(sigmaScopesKey, out sigmaScopesItem);
                int maximumKey = sigmaScopesItem.IndexMax;
                //<-----sigmaNode key --- global

                max = index(highest(x), maximumKey);
            }
            return(true);
        }