LinkedList.Remove C# (CSharp) Method

    public Boolean Remove(Object obj)
    {
        LinkedListNode ptrEnd = m_start;
        if (  ptrEnd != null &&
            (
            (ptrEnd.obj == null && obj == null)
            ||
            (ptrEnd.obj != null && ptrEnd.obj.Equals( obj ) )
            )                                                        )
        {
            m_start = ptrEnd.next;
            if ( m_start != null )
            {
                m_start.last = null;
            }
            m_Count--;
            return true;
        }
        while( ptrEnd != null )
        {
            if ( (ptrEnd.obj == null && obj == null) ||
                (ptrEnd.obj != null && ptrEnd.obj.Equals( obj ) )  )
            {
                m_Count--;
                if ( m_Count == 0 )
                {
                    m_start = null;
                    return true;
                }
                if ( ptrEnd.next != null )
                {
                    ptrEnd.next.last = ptrEnd.last;
                }
                if ( ptrEnd.last != null )
                {
                    ptrEnd.last.next = ptrEnd.next;
                }
                ptrEnd.next = null;
                ptrEnd.last = null;
                ptrEnd = null;
                return true;
            }
            ptrEnd = ptrEnd.next;
        }
        return false;
    }
    public Boolean Contains(Object obj)

        public override Tree<SyntaxToken> Read(LinkedList<MixedToken> tokens, Grammar grammar)
        {
            // Do not create negate syntax token if we are able to create a subtract syntax token
            var lastNegateNode = tokens.FindLastNode(t => t.Value.IsLexicToken &&
                t.Value.LexicToken is SubtractToken && (t.Previous != null && !t.Previous.Value.IsTree || t.Previous == null));
            if (lastNegateNode != null) {
                var next = lastNegateNode.Next;
                if (next == null)
                    throw new ParserException("Unexpected argument of 'negate' operator.");

                if (!next.Value.IsTree)
                    throw new ParserException("Argument of 'negate' operator was not parsed.");

                NegateSyntaxToken token = new NegateSyntaxToken();
                Tree<SyntaxToken> tree = new Tree<SyntaxToken>(token);
                tree.Leafs.Add(next.Value.Tree);

                tokens.AddBefore(lastNegateNode, new MixedToken(tree));
                tokens.Remove(lastNegateNode);
                tokens.Remove(next);

                return tree;
            }

            return null;
        }