/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/

/* NOTE: This file is AUTO GENERATED by qtokenautomaton2cpp.xsl. */

#include "qxslttokenlookup_p.h"

QT_BEGIN_NAMESPACE

using namespace QPatternist;

XSLTTokenLookup::NodeName XSLTTokenLookup::classifier2(const QChar *data)

        {
            if (data[0] == 97)


                    {
                    
                            if(data[1] == 115)
                        

                return As;
            
                    }

                else if (data[0] == 105)


                    {
                    if (data[1] == 100)


                    {
                    

                return Id;
            
                    }

                else if (data[1] == 102)


                    {
                    

                return If;
            
                    }

                
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier3(const QChar *data)

        {
            if (data[0] == 107)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 121
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
                        

                return Key;
            
                    }

                else if (data[0] == 117)


                    {
                    
                            static const unsigned short string[] =
                            {
                                115, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
                        

                return Use;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier4(const QChar *data)

        {
            if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 112, 121
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return Copy;
            
                    }

                else if (data[0] == 104)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 101, 102
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return Href;
            
                    }

                else if (data[0] == 108)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 110, 103
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return Lang;
            
                    }

                else if (data[0] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 100, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return Mode;
            
                    }

                else if (data[0] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 109, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return Name;
            
                    }

                else if (data[0] == 115)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 114, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return Sort;
            
                    }

                else if (data[0] == 116)


                    {
                    if (data[1] == 101)


                    {
                    if (data[2] == 115)


                    {
                    
                            if(data[3] == 116)
                        

                return Test;
            
                    }

                else if (data[2] == 120)


                    {
                    
                            if(data[3] == 116)
                        

                return Text;
            
                    }

                
                    }

                else if (data[1] == 121)


                    {
                    
                            static const unsigned short string[] =
                            {
                                112, 101
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
                        

                return Type;
            
                    }

                
                    }

                else if (data[0] == 119)


                    {
                    
                            static const unsigned short string[] =
                            {
                                104, 101, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
                        

                return When;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier5(const QChar *data)

        {
            if (data[0] == 102)


                    {
                    
                            static const unsigned short string[] =
                            {
                                108, 97, 103, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
                        

                return Flags;
            
                    }

                else if (data[0] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 116, 99, 104
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
                        

                return Match;
            
                    }

                else if (data[0] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 100, 101, 114
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
                        

                return Order;
            
                    }

                else if (data[0] == 112)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 114, 97, 109
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
                        

                return Param;
            
                    }

                else if (data[0] == 114)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 103, 101, 120
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
                        

                return Regex;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier6(const QChar *data)

        {
            if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                104, 111, 111, 115, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
                        

                return Choose;
            
                    }

                else if (data[0] == 102)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 114, 109, 97, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
                        

                return Format;
            
                    }

                else if (data[0] == 105)


                    {
                    if (data[1] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                112, 111, 114, 116
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
                        

                return Import;
            
                    }

                else if (data[1] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                100, 101, 110, 116
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
                        

                return Indent;
            
                    }

                
                    }

                else if (data[0] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 116, 104, 111, 100
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
                        

                return Method;
            
                    }

                else if (data[0] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                117, 116, 112, 117, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
                        

                return Output;
            
                    }

                else if (data[0] == 115)


                    {
                    if (data[1] == 101)


                    {
                    
                            static const unsigned short string[] =
                            {
                                108, 101, 99, 116
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
                        

                return Select;
            
                    }

                else if (data[1] == 116)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 98, 108, 101
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
                        

                return Stable;
            
                    }

                
                    }

                else if (data[0] == 116)


                    {
                    
                            static const unsigned short string[] =
                            {
                                117, 110, 110, 101, 108
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
                        

                return Tunnel;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier7(const QChar *data)

        {
            if (data[0] == 99)


                    {
                    if (data[1] == 111)


                    {
                    if (data[2] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                109, 101, 110, 116
                            };
                            if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0)
                        

                return Comment;
            
                    }

                else if (data[2] == 112)


                    {
                    
                            static const unsigned short string[] =
                            {
                                121, 45, 111, 102
                            };
                            if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0)
                        

                return CopyOf;
            
                    }

                
                    }

                
                    }

                else if (data[0] == 101)


                    {
                    
                            static const unsigned short string[] =
                            {
                                108, 101, 109, 101, 110, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
                        

                return Element;
            
                    }

                else if (data[0] == 105)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 99, 108, 117, 100, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
                        

                return Include;
            
                    }

                else if (data[0] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 115, 115, 97, 103, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
                        

                return Message;
            
                    }

                else if (data[0] == 118)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 114, 115, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
                        

                return Version;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier8(const QChar *data)

        {
            if (data[0] == 100)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 99, 117, 109, 101, 110, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return Document;
            
                    }

                else if (data[0] == 101)


                    {
                    if (data[1] == 108)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 109, 101, 110, 116, 115
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
                        

                return Elements;
            
                    }

                else if (data[1] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                99, 111, 100, 105, 110, 103
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
                        

                return Encoding;
            
                    }

                
                    }

                else if (data[0] == 102)


                    {
                    if (data[1] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 45, 101, 97, 99, 104
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
                        

                return ForEach;
            
                    }

                else if (data[1] == 117)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 99, 116, 105, 111, 110
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
                        

                return Function;
            
                    }

                
                    }

                else if (data[0] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                118, 101, 114, 114, 105, 100, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return Override;
            
                    }

                else if (data[0] == 112)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 105, 111, 114, 105, 116, 121
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return Priority;
            
                    }

                else if (data[0] == 114)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 113, 117, 105, 114, 101, 100
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return Required;
            
                    }

                else if (data[0] == 115)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 113, 117, 101, 110, 99, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return Sequence;
            
                    }

                else if (data[0] == 116)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 109, 112, 108, 97, 116, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return Template;
            
                    }

                else if (data[0] == 117)


                    {
                    
                            static const unsigned short string[] =
                            {
                                115, 101, 45, 119, 104, 101, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
                        

                return UseWhen;
            
                    }

                else if (data[0] == 118)


                    {
                    if (data[1] == 97)


                    {
                    if (data[2] == 108)


                    {
                    
                            static const unsigned short string[] =
                            {
                                117, 101, 45, 111, 102
                            };
                            if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
                        

                return ValueOf;
            
                    }

                else if (data[2] == 114)


                    {
                    
                            static const unsigned short string[] =
                            {
                                105, 97, 98, 108, 101
                            };
                            if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
                        

                return Variable;
            
                    }

                
                    }

                
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier9(const QChar *data)

        {
            if (data[0] == 97)


                    {
                    
                            static const unsigned short string[] =
                            {
                                116, 116, 114, 105, 98, 117, 116, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
                        

                return Attribute;
            
                    }

                else if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 108, 108, 97, 116, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
                        

                return Collation;
            
                    }

                else if (data[0] == 100)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 116, 97, 45, 116, 121, 112, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
                        

                return DataType;
            
                    }

                else if (data[0] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 109, 101, 115, 112, 97, 99, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
                        

                return Namespace;
            
                    }

                else if (data[0] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                116, 104, 101, 114, 119, 105, 115, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
                        

                return Otherwise;
            
                    }

                else if (data[0] == 115)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 112, 97, 114, 97, 116, 111, 114
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
                        

                return Separator;
            
                    }

                else if (data[0] == 116)


                    {
                    if (data[1] == 101)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 109, 105, 110, 97, 116, 101
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
                        

                return Terminate;
            
                    }

                else if (data[1] == 114)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 110, 115, 102, 111, 114, 109
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
                        

                return Transform;
            
                    }

                
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier10(const QChar *data)

        {
            if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 115, 101, 45, 111, 114, 100, 101, 114
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
                        

                return CaseOrder;
            
                    }

                else if (data[0] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 100, 105, 97, 45, 116, 121, 112, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
                        

                return MediaType;
            
                    }

                else if (data[0] == 115)


                    {
                    if (data[1] == 116)


                    {
                    if (data[2] == 97)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 100, 97, 108, 111, 110, 101
                            };
                            if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0)
                        

                return Standalone;
            
                    }

                else if (data[2] == 121)


                    {
                    
                            static const unsigned short string[] =
                            {
                                108, 101, 115, 104, 101, 101, 116
                            };
                            if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0)
                        

                return Stylesheet;
            
                    }

                
                    }

                
                    }

                else if (data[0] == 118)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 108, 105, 100, 97, 116, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
                        

                return Validation;
            
                    }

                else if (data[0] == 119)


                    {
                    
                            static const unsigned short string[] =
                            {
                                105, 116, 104, 45, 112, 97, 114, 97, 109
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
                        

                return WithParam;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier11(const QChar *data)

        {
            
                            static const unsigned short string[] =
                            {
                                115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101
                            };
                            if(memcmp(&data[0], &string, sizeof(QChar) * 11) == 0)
                        

                return StripSpace;
            

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier12(const QChar *data)

        {
            
                            static const unsigned short string[] =
                            {
                                112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116
                            };
                            if(memcmp(&data[0], &string, sizeof(QChar) * 12) == 0)
                        

                return PerformSort;
            

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier13(const QChar *data)

        {
            if (data[0] == 97)


                    {
                    
                            static const unsigned short string[] =
                            {
                                116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
                        

                return AttributeSet;
            
                    }

                else if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
                        

                return CallTemplate;
            
                    }

                else if (data[0] == 105)


                    {
                    
                            static const unsigned short string[] =
                            {
                                109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
                        

                return ImportSchema;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier14(const QChar *data)

        {
            if (data[0] == 97)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
                        

                return AnalyzeString;
            
                    }

                else if (data[0] == 100)


                    {
                    if (data[1] == 111)


                    {
                    if (data[2] == 99)


                    {
                    if (data[3] == 116)


                    {
                    if (data[4] == 121)


                    {
                    if (data[5] == 112)


                    {
                    if (data[6] == 101)


                    {
                    if (data[7] == 45)


                    {
                    if (data[8] == 112)


                    {
                    
                            static const unsigned short string[] =
                            {
                                117, 98, 108, 105, 99
                            };
                            if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0)
                        

                return DoctypePublic;
            
                    }

                else if (data[8] == 115)


                    {
                    
                            static const unsigned short string[] =
                            {
                                121, 115, 116, 101, 109
                            };
                            if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0)
                        

                return DoctypeSystem;
            
                    }

                
                    }

                
                    }

                
                    }

                
                    }

                
                    }

                
                    }

                
                    }

                
                    }

                else if (data[0] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
                        

                return OutputVersion;
            
                    }

                else if (data[0] == 112)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
                        

                return PreserveSpace;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier15(const QChar *data)

        {
            if (data[0] == 97)


                    {
                    
                            static const unsigned short string[] =
                            {
                                112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
                        

                return ApplyTemplates;
            
                    }

                else if (data[0] == 98)


                    {
                    
                            static const unsigned short string[] =
                            {
                                121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
                        

                return ByteOrderMark;
            
                    }

                else if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
                        

                return CopyNamespaces;
            
                    }

                else if (data[0] == 114)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
                        

                return ResultDocument;
            
                    }

                else if (data[0] == 115)


                    {
                    
                            static const unsigned short string[] =
                            {
                                99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
                        

                return SchemaLocation;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier17(const QChar *data)

        {
            
                            static const unsigned short string[] =
                            {
                                100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110
                            };
                            if(memcmp(&data[0], &string, sizeof(QChar) * 17) == 0)
                        

                return DefaultCollation;
            

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier18(const QChar *data)

        {
            if (data[0] == 100)


                    {
                    
                            static const unsigned short string[] =
                            {
                                101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
                        

                return DefaultValidation;
            
                    }

                else if (data[0] == 105)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
                        

                return InheritNamespaces;
            
                    }

                else if (data[0] == 109)


                    {
                    
                            static const unsigned short string[] =
                            {
                                97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
                        

                return MatchingSubstring;
            
                    }

                else if (data[0] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
                        

                return NormalizationForm;
            
                    }

                else if (data[0] == 117)


                    {
                    if (data[1] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115
                            };
                            if(memcmp(&data[2], &string, sizeof(QChar) * 16) == 0)
                        

                return UndeclarePrefixes;
            
                    }

                else if (data[1] == 115)


                    {
                    if (data[2] == 101)


                    {
                    if (data[3] == 45)


                    {
                    if (data[4] == 97)


                    {
                    
                            static const unsigned short string[] =
                            {
                                116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115
                            };
                            if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0)
                        

                return UseAttributeSets;
            
                    }

                else if (data[4] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115
                            };
                            if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0)
                        

                return UseCharacterMaps;
            
                    }

                
                    }

                
                    }

                
                    }

                
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier20(const QChar *data)

        {
            if (data[0] == 105)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0)
                        

                return IncludeContentType;
            
                    }

                else if (data[0] == 111)


                    {
                    
                            static const unsigned short string[] =
                            {
                                109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0)
                        

                return OmitXmlDeclaration;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier21(const QChar *data)

        {
            
                            static const unsigned short string[] =
                            {
                                101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115
                            };
                            if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0)
                        

                return EscapeUriAttributes;
            

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier22(const QChar *data)

        {
            if (data[0] == 99)


                    {
                    
                            static const unsigned short string[] =
                            {
                                100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
                        

                return CdataSectionElements;
            
                    }

                else if (data[0] == 105)


                    {
                    
                            static const unsigned short string[] =
                            {
                                110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
                        

                return InputTypeAnnotations;
            
                    }

                else if (data[0] == 110)


                    {
                    
                            static const unsigned short string[] =
                            {
                                111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
                        

                return NonMatchingSubstring;
            
                    }

                else if (data[0] == 112)


                    {
                    
                            static const unsigned short string[] =
                            {
                                114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
                        

                return ProcessingInstruction;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier23(const QChar *data)

        {
            if (data[0] == 101)


                    {
                    
                            static const unsigned short string[] =
                            {
                                120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0)
                        

                return ExcludeResultPrefixes;
            
                    }

                else if (data[0] == 120)


                    {
                    
                            static const unsigned short string[] =
                            {
                                112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101
                            };
                            if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0)
                        

                return XpathDefaultNamespace;
            
                    }

                

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::classifier26(const QChar *data)

        {
            
                            static const unsigned short string[] =
                            {
                                101, 120, 116, 101, 110, 115, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115
                            };
                            if(memcmp(&data[0], &string, sizeof(QChar) * 26) == 0)
                        

                return ExtensionElementPrefixes;
            

            return NoKeyword;
        }
    XSLTTokenLookup::NodeName XSLTTokenLookup::toToken(const QChar *data, int length)
            {
                switch(length)
                {
                    
                        case 2:
                            return classifier2(data);

                    
                        case 3:
                            return classifier3(data);

                    
                        case 4:
                            return classifier4(data);

                    
                        case 5:
                            return classifier5(data);

                    
                        case 6:
                            return classifier6(data);

                    
                        case 7:
                            return classifier7(data);

                    
                        case 8:
                            return classifier8(data);

                    
                        case 9:
                            return classifier9(data);

                    
                        case 10:
                            return classifier10(data);

                    
                        case 11:
                            return classifier11(data);

                    
                        case 12:
                            return classifier12(data);

                    
                        case 13:
                            return classifier13(data);

                    
                        case 14:
                            return classifier14(data);

                    
                        case 15:
                            return classifier15(data);

                    
                        case 17:
                            return classifier17(data);

                    
                        case 18:
                            return classifier18(data);

                    
                        case 20:
                            return classifier20(data);

                    
                        case 21:
                            return classifier21(data);

                    
                        case 22:
                            return classifier22(data);

                    
                        case 23:
                            return classifier23(data);

                    
                        case 26:
                            return classifier26(data);

                    
                        default:
                            return NoKeyword;
                }
            }

            
                QString XSLTTokenLookup::toString(NodeName token)
                {
                    const unsigned short *data = 0;
                    int length = 0;

                    switch(token)
                    {
                    
                        case AnalyzeString:
                        {
                            static const unsigned short staticallyStoredAnalyzeString[] =
                            {
                            97, 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103, 0
                            };
                            data = staticallyStoredAnalyzeString;
                            length = 14;
                            break;
                        }
                    
                        case ApplyTemplates:
                        {
                            static const unsigned short staticallyStoredApplyTemplates[] =
                            {
                            97, 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115, 0
                            };
                            data = staticallyStoredApplyTemplates;
                            length = 15;
                            break;
                        }
                    
                        case As:
                        {
                            static const unsigned short staticallyStoredAs[] =
                            {
                            97, 115, 0
                            };
                            data = staticallyStoredAs;
                            length = 2;
                            break;
                        }
                    
                        case Attribute:
                        {
                            static const unsigned short staticallyStoredAttribute[] =
                            {
                            97, 116, 116, 114, 105, 98, 117, 116, 101, 0
                            };
                            data = staticallyStoredAttribute;
                            length = 9;
                            break;
                        }
                    
                        case AttributeSet:
                        {
                            static const unsigned short staticallyStoredAttributeSet[] =
                            {
                            97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 0
                            };
                            data = staticallyStoredAttributeSet;
                            length = 13;
                            break;
                        }
                    
                        case ByteOrderMark:
                        {
                            static const unsigned short staticallyStoredByteOrderMark[] =
                            {
                            98, 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107, 0
                            };
                            data = staticallyStoredByteOrderMark;
                            length = 15;
                            break;
                        }
                    
                        case CallTemplate:
                        {
                            static const unsigned short staticallyStoredCallTemplate[] =
                            {
                            99, 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101, 0
                            };
                            data = staticallyStoredCallTemplate;
                            length = 13;
                            break;
                        }
                    
                        case CaseOrder:
                        {
                            static const unsigned short staticallyStoredCaseOrder[] =
                            {
                            99, 97, 115, 101, 45, 111, 114, 100, 101, 114, 0
                            };
                            data = staticallyStoredCaseOrder;
                            length = 10;
                            break;
                        }
                    
                        case CdataSectionElements:
                        {
                            static const unsigned short staticallyStoredCdataSectionElements[] =
                            {
                            99, 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115, 0
                            };
                            data = staticallyStoredCdataSectionElements;
                            length = 22;
                            break;
                        }
                    
                        case Choose:
                        {
                            static const unsigned short staticallyStoredChoose[] =
                            {
                            99, 104, 111, 111, 115, 101, 0
                            };
                            data = staticallyStoredChoose;
                            length = 6;
                            break;
                        }
                    
                        case Collation:
                        {
                            static const unsigned short staticallyStoredCollation[] =
                            {
                            99, 111, 108, 108, 97, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredCollation;
                            length = 9;
                            break;
                        }
                    
                        case Comment:
                        {
                            static const unsigned short staticallyStoredComment[] =
                            {
                            99, 111, 109, 109, 101, 110, 116, 0
                            };
                            data = staticallyStoredComment;
                            length = 7;
                            break;
                        }
                    
                        case Copy:
                        {
                            static const unsigned short staticallyStoredCopy[] =
                            {
                            99, 111, 112, 121, 0
                            };
                            data = staticallyStoredCopy;
                            length = 4;
                            break;
                        }
                    
                        case CopyNamespaces:
                        {
                            static const unsigned short staticallyStoredCopyNamespaces[] =
                            {
                            99, 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0
                            };
                            data = staticallyStoredCopyNamespaces;
                            length = 15;
                            break;
                        }
                    
                        case CopyOf:
                        {
                            static const unsigned short staticallyStoredCopyOf[] =
                            {
                            99, 111, 112, 121, 45, 111, 102, 0
                            };
                            data = staticallyStoredCopyOf;
                            length = 7;
                            break;
                        }
                    
                        case DataType:
                        {
                            static const unsigned short staticallyStoredDataType[] =
                            {
                            100, 97, 116, 97, 45, 116, 121, 112, 101, 0
                            };
                            data = staticallyStoredDataType;
                            length = 9;
                            break;
                        }
                    
                        case DefaultCollation:
                        {
                            static const unsigned short staticallyStoredDefaultCollation[] =
                            {
                            100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredDefaultCollation;
                            length = 17;
                            break;
                        }
                    
                        case DefaultValidation:
                        {
                            static const unsigned short staticallyStoredDefaultValidation[] =
                            {
                            100, 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredDefaultValidation;
                            length = 18;
                            break;
                        }
                    
                        case DoctypePublic:
                        {
                            static const unsigned short staticallyStoredDoctypePublic[] =
                            {
                            100, 111, 99, 116, 121, 112, 101, 45, 112, 117, 98, 108, 105, 99, 0
                            };
                            data = staticallyStoredDoctypePublic;
                            length = 14;
                            break;
                        }
                    
                        case DoctypeSystem:
                        {
                            static const unsigned short staticallyStoredDoctypeSystem[] =
                            {
                            100, 111, 99, 116, 121, 112, 101, 45, 115, 121, 115, 116, 101, 109, 0
                            };
                            data = staticallyStoredDoctypeSystem;
                            length = 14;
                            break;
                        }
                    
                        case Document:
                        {
                            static const unsigned short staticallyStoredDocument[] =
                            {
                            100, 111, 99, 117, 109, 101, 110, 116, 0
                            };
                            data = staticallyStoredDocument;
                            length = 8;
                            break;
                        }
                    
                        case Element:
                        {
                            static const unsigned short staticallyStoredElement[] =
                            {
                            101, 108, 101, 109, 101, 110, 116, 0
                            };
                            data = staticallyStoredElement;
                            length = 7;
                            break;
                        }
                    
                        case Elements:
                        {
                            static const unsigned short staticallyStoredElements[] =
                            {
                            101, 108, 101, 109, 101, 110, 116, 115, 0
                            };
                            data = staticallyStoredElements;
                            length = 8;
                            break;
                        }
                    
                        case Encoding:
                        {
                            static const unsigned short staticallyStoredEncoding[] =
                            {
                            101, 110, 99, 111, 100, 105, 110, 103, 0
                            };
                            data = staticallyStoredEncoding;
                            length = 8;
                            break;
                        }
                    
                        case EscapeUriAttributes:
                        {
                            static const unsigned short staticallyStoredEscapeUriAttributes[] =
                            {
                            101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0
                            };
                            data = staticallyStoredEscapeUriAttributes;
                            length = 21;
                            break;
                        }
                    
                        case ExcludeResultPrefixes:
                        {
                            static const unsigned short staticallyStoredExcludeResultPrefixes[] =
                            {
                            101, 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
                            };
                            data = staticallyStoredExcludeResultPrefixes;
                            length = 23;
                            break;
                        }
                    
                        case ExtensionElementPrefixes:
                        {
                            static const unsigned short staticallyStoredExtensionElementPrefixes[] =
                            {
                            101, 120, 116, 101, 110, 115, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
                            };
                            data = staticallyStoredExtensionElementPrefixes;
                            length = 26;
                            break;
                        }
                    
                        case Flags:
                        {
                            static const unsigned short staticallyStoredFlags[] =
                            {
                            102, 108, 97, 103, 115, 0
                            };
                            data = staticallyStoredFlags;
                            length = 5;
                            break;
                        }
                    
                        case ForEach:
                        {
                            static const unsigned short staticallyStoredForEach[] =
                            {
                            102, 111, 114, 45, 101, 97, 99, 104, 0
                            };
                            data = staticallyStoredForEach;
                            length = 8;
                            break;
                        }
                    
                        case Format:
                        {
                            static const unsigned short staticallyStoredFormat[] =
                            {
                            102, 111, 114, 109, 97, 116, 0
                            };
                            data = staticallyStoredFormat;
                            length = 6;
                            break;
                        }
                    
                        case Function:
                        {
                            static const unsigned short staticallyStoredFunction[] =
                            {
                            102, 117, 110, 99, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredFunction;
                            length = 8;
                            break;
                        }
                    
                        case Href:
                        {
                            static const unsigned short staticallyStoredHref[] =
                            {
                            104, 114, 101, 102, 0
                            };
                            data = staticallyStoredHref;
                            length = 4;
                            break;
                        }
                    
                        case Id:
                        {
                            static const unsigned short staticallyStoredId[] =
                            {
                            105, 100, 0
                            };
                            data = staticallyStoredId;
                            length = 2;
                            break;
                        }
                    
                        case If:
                        {
                            static const unsigned short staticallyStoredIf[] =
                            {
                            105, 102, 0
                            };
                            data = staticallyStoredIf;
                            length = 2;
                            break;
                        }
                    
                        case Import:
                        {
                            static const unsigned short staticallyStoredImport[] =
                            {
                            105, 109, 112, 111, 114, 116, 0
                            };
                            data = staticallyStoredImport;
                            length = 6;
                            break;
                        }
                    
                        case ImportSchema:
                        {
                            static const unsigned short staticallyStoredImportSchema[] =
                            {
                            105, 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97, 0
                            };
                            data = staticallyStoredImportSchema;
                            length = 13;
                            break;
                        }
                    
                        case Include:
                        {
                            static const unsigned short staticallyStoredInclude[] =
                            {
                            105, 110, 99, 108, 117, 100, 101, 0
                            };
                            data = staticallyStoredInclude;
                            length = 7;
                            break;
                        }
                    
                        case IncludeContentType:
                        {
                            static const unsigned short staticallyStoredIncludeContentType[] =
                            {
                            105, 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 0
                            };
                            data = staticallyStoredIncludeContentType;
                            length = 20;
                            break;
                        }
                    
                        case Indent:
                        {
                            static const unsigned short staticallyStoredIndent[] =
                            {
                            105, 110, 100, 101, 110, 116, 0
                            };
                            data = staticallyStoredIndent;
                            length = 6;
                            break;
                        }
                    
                        case InheritNamespaces:
                        {
                            static const unsigned short staticallyStoredInheritNamespaces[] =
                            {
                            105, 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0
                            };
                            data = staticallyStoredInheritNamespaces;
                            length = 18;
                            break;
                        }
                    
                        case InputTypeAnnotations:
                        {
                            static const unsigned short staticallyStoredInputTypeAnnotations[] =
                            {
                            105, 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115, 0
                            };
                            data = staticallyStoredInputTypeAnnotations;
                            length = 22;
                            break;
                        }
                    
                        case Key:
                        {
                            static const unsigned short staticallyStoredKey[] =
                            {
                            107, 101, 121, 0
                            };
                            data = staticallyStoredKey;
                            length = 3;
                            break;
                        }
                    
                        case Lang:
                        {
                            static const unsigned short staticallyStoredLang[] =
                            {
                            108, 97, 110, 103, 0
                            };
                            data = staticallyStoredLang;
                            length = 4;
                            break;
                        }
                    
                        case Match:
                        {
                            static const unsigned short staticallyStoredMatch[] =
                            {
                            109, 97, 116, 99, 104, 0
                            };
                            data = staticallyStoredMatch;
                            length = 5;
                            break;
                        }
                    
                        case MatchingSubstring:
                        {
                            static const unsigned short staticallyStoredMatchingSubstring[] =
                            {
                            109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0
                            };
                            data = staticallyStoredMatchingSubstring;
                            length = 18;
                            break;
                        }
                    
                        case MediaType:
                        {
                            static const unsigned short staticallyStoredMediaType[] =
                            {
                            109, 101, 100, 105, 97, 45, 116, 121, 112, 101, 0
                            };
                            data = staticallyStoredMediaType;
                            length = 10;
                            break;
                        }
                    
                        case Message:
                        {
                            static const unsigned short staticallyStoredMessage[] =
                            {
                            109, 101, 115, 115, 97, 103, 101, 0
                            };
                            data = staticallyStoredMessage;
                            length = 7;
                            break;
                        }
                    
                        case Method:
                        {
                            static const unsigned short staticallyStoredMethod[] =
                            {
                            109, 101, 116, 104, 111, 100, 0
                            };
                            data = staticallyStoredMethod;
                            length = 6;
                            break;
                        }
                    
                        case Mode:
                        {
                            static const unsigned short staticallyStoredMode[] =
                            {
                            109, 111, 100, 101, 0
                            };
                            data = staticallyStoredMode;
                            length = 4;
                            break;
                        }
                    
                        case Name:
                        {
                            static const unsigned short staticallyStoredName[] =
                            {
                            110, 97, 109, 101, 0
                            };
                            data = staticallyStoredName;
                            length = 4;
                            break;
                        }
                    
                        case Namespace:
                        {
                            static const unsigned short staticallyStoredNamespace[] =
                            {
                            110, 97, 109, 101, 115, 112, 97, 99, 101, 0
                            };
                            data = staticallyStoredNamespace;
                            length = 9;
                            break;
                        }
                    
                        case NonMatchingSubstring:
                        {
                            static const unsigned short staticallyStoredNonMatchingSubstring[] =
                            {
                            110, 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0
                            };
                            data = staticallyStoredNonMatchingSubstring;
                            length = 22;
                            break;
                        }
                    
                        case NormalizationForm:
                        {
                            static const unsigned short staticallyStoredNormalizationForm[] =
                            {
                            110, 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109, 0
                            };
                            data = staticallyStoredNormalizationForm;
                            length = 18;
                            break;
                        }
                    
                        case OmitXmlDeclaration:
                        {
                            static const unsigned short staticallyStoredOmitXmlDeclaration[] =
                            {
                            111, 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredOmitXmlDeclaration;
                            length = 20;
                            break;
                        }
                    
                        case Order:
                        {
                            static const unsigned short staticallyStoredOrder[] =
                            {
                            111, 114, 100, 101, 114, 0
                            };
                            data = staticallyStoredOrder;
                            length = 5;
                            break;
                        }
                    
                        case Otherwise:
                        {
                            static const unsigned short staticallyStoredOtherwise[] =
                            {
                            111, 116, 104, 101, 114, 119, 105, 115, 101, 0
                            };
                            data = staticallyStoredOtherwise;
                            length = 9;
                            break;
                        }
                    
                        case Output:
                        {
                            static const unsigned short staticallyStoredOutput[] =
                            {
                            111, 117, 116, 112, 117, 116, 0
                            };
                            data = staticallyStoredOutput;
                            length = 6;
                            break;
                        }
                    
                        case OutputVersion:
                        {
                            static const unsigned short staticallyStoredOutputVersion[] =
                            {
                            111, 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110, 0
                            };
                            data = staticallyStoredOutputVersion;
                            length = 14;
                            break;
                        }
                    
                        case Override:
                        {
                            static const unsigned short staticallyStoredOverride[] =
                            {
                            111, 118, 101, 114, 114, 105, 100, 101, 0
                            };
                            data = staticallyStoredOverride;
                            length = 8;
                            break;
                        }
                    
                        case Param:
                        {
                            static const unsigned short staticallyStoredParam[] =
                            {
                            112, 97, 114, 97, 109, 0
                            };
                            data = staticallyStoredParam;
                            length = 5;
                            break;
                        }
                    
                        case PerformSort:
                        {
                            static const unsigned short staticallyStoredPerformSort[] =
                            {
                            112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116, 0
                            };
                            data = staticallyStoredPerformSort;
                            length = 12;
                            break;
                        }
                    
                        case PreserveSpace:
                        {
                            static const unsigned short staticallyStoredPreserveSpace[] =
                            {
                            112, 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101, 0
                            };
                            data = staticallyStoredPreserveSpace;
                            length = 14;
                            break;
                        }
                    
                        case Priority:
                        {
                            static const unsigned short staticallyStoredPriority[] =
                            {
                            112, 114, 105, 111, 114, 105, 116, 121, 0
                            };
                            data = staticallyStoredPriority;
                            length = 8;
                            break;
                        }
                    
                        case ProcessingInstruction:
                        {
                            static const unsigned short staticallyStoredProcessingInstruction[] =
                            {
                            112, 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredProcessingInstruction;
                            length = 22;
                            break;
                        }
                    
                        case Regex:
                        {
                            static const unsigned short staticallyStoredRegex[] =
                            {
                            114, 101, 103, 101, 120, 0
                            };
                            data = staticallyStoredRegex;
                            length = 5;
                            break;
                        }
                    
                        case Required:
                        {
                            static const unsigned short staticallyStoredRequired[] =
                            {
                            114, 101, 113, 117, 105, 114, 101, 100, 0
                            };
                            data = staticallyStoredRequired;
                            length = 8;
                            break;
                        }
                    
                        case ResultDocument:
                        {
                            static const unsigned short staticallyStoredResultDocument[] =
                            {
                            114, 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116, 0
                            };
                            data = staticallyStoredResultDocument;
                            length = 15;
                            break;
                        }
                    
                        case SchemaLocation:
                        {
                            static const unsigned short staticallyStoredSchemaLocation[] =
                            {
                            115, 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredSchemaLocation;
                            length = 15;
                            break;
                        }
                    
                        case Select:
                        {
                            static const unsigned short staticallyStoredSelect[] =
                            {
                            115, 101, 108, 101, 99, 116, 0
                            };
                            data = staticallyStoredSelect;
                            length = 6;
                            break;
                        }
                    
                        case Separator:
                        {
                            static const unsigned short staticallyStoredSeparator[] =
                            {
                            115, 101, 112, 97, 114, 97, 116, 111, 114, 0
                            };
                            data = staticallyStoredSeparator;
                            length = 9;
                            break;
                        }
                    
                        case Sequence:
                        {
                            static const unsigned short staticallyStoredSequence[] =
                            {
                            115, 101, 113, 117, 101, 110, 99, 101, 0
                            };
                            data = staticallyStoredSequence;
                            length = 8;
                            break;
                        }
                    
                        case Sort:
                        {
                            static const unsigned short staticallyStoredSort[] =
                            {
                            115, 111, 114, 116, 0
                            };
                            data = staticallyStoredSort;
                            length = 4;
                            break;
                        }
                    
                        case Stable:
                        {
                            static const unsigned short staticallyStoredStable[] =
                            {
                            115, 116, 97, 98, 108, 101, 0
                            };
                            data = staticallyStoredStable;
                            length = 6;
                            break;
                        }
                    
                        case Standalone:
                        {
                            static const unsigned short staticallyStoredStandalone[] =
                            {
                            115, 116, 97, 110, 100, 97, 108, 111, 110, 101, 0
                            };
                            data = staticallyStoredStandalone;
                            length = 10;
                            break;
                        }
                    
                        case StripSpace:
                        {
                            static const unsigned short staticallyStoredStripSpace[] =
                            {
                            115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101, 0
                            };
                            data = staticallyStoredStripSpace;
                            length = 11;
                            break;
                        }
                    
                        case Stylesheet:
                        {
                            static const unsigned short staticallyStoredStylesheet[] =
                            {
                            115, 116, 121, 108, 101, 115, 104, 101, 101, 116, 0
                            };
                            data = staticallyStoredStylesheet;
                            length = 10;
                            break;
                        }
                    
                        case Template:
                        {
                            static const unsigned short staticallyStoredTemplate[] =
                            {
                            116, 101, 109, 112, 108, 97, 116, 101, 0
                            };
                            data = staticallyStoredTemplate;
                            length = 8;
                            break;
                        }
                    
                        case Terminate:
                        {
                            static const unsigned short staticallyStoredTerminate[] =
                            {
                            116, 101, 114, 109, 105, 110, 97, 116, 101, 0
                            };
                            data = staticallyStoredTerminate;
                            length = 9;
                            break;
                        }
                    
                        case Test:
                        {
                            static const unsigned short staticallyStoredTest[] =
                            {
                            116, 101, 115, 116, 0
                            };
                            data = staticallyStoredTest;
                            length = 4;
                            break;
                        }
                    
                        case Text:
                        {
                            static const unsigned short staticallyStoredText[] =
                            {
                            116, 101, 120, 116, 0
                            };
                            data = staticallyStoredText;
                            length = 4;
                            break;
                        }
                    
                        case Transform:
                        {
                            static const unsigned short staticallyStoredTransform[] =
                            {
                            116, 114, 97, 110, 115, 102, 111, 114, 109, 0
                            };
                            data = staticallyStoredTransform;
                            length = 9;
                            break;
                        }
                    
                        case Tunnel:
                        {
                            static const unsigned short staticallyStoredTunnel[] =
                            {
                            116, 117, 110, 110, 101, 108, 0
                            };
                            data = staticallyStoredTunnel;
                            length = 6;
                            break;
                        }
                    
                        case Type:
                        {
                            static const unsigned short staticallyStoredType[] =
                            {
                            116, 121, 112, 101, 0
                            };
                            data = staticallyStoredType;
                            length = 4;
                            break;
                        }
                    
                        case UndeclarePrefixes:
                        {
                            static const unsigned short staticallyStoredUndeclarePrefixes[] =
                            {
                            117, 110, 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
                            };
                            data = staticallyStoredUndeclarePrefixes;
                            length = 18;
                            break;
                        }
                    
                        case Use:
                        {
                            static const unsigned short staticallyStoredUse[] =
                            {
                            117, 115, 101, 0
                            };
                            data = staticallyStoredUse;
                            length = 3;
                            break;
                        }
                    
                        case UseAttributeSets:
                        {
                            static const unsigned short staticallyStoredUseAttributeSets[] =
                            {
                            117, 115, 101, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115, 0
                            };
                            data = staticallyStoredUseAttributeSets;
                            length = 18;
                            break;
                        }
                    
                        case UseCharacterMaps:
                        {
                            static const unsigned short staticallyStoredUseCharacterMaps[] =
                            {
                            117, 115, 101, 45, 99, 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115, 0
                            };
                            data = staticallyStoredUseCharacterMaps;
                            length = 18;
                            break;
                        }
                    
                        case UseWhen:
                        {
                            static const unsigned short staticallyStoredUseWhen[] =
                            {
                            117, 115, 101, 45, 119, 104, 101, 110, 0
                            };
                            data = staticallyStoredUseWhen;
                            length = 8;
                            break;
                        }
                    
                        case Validation:
                        {
                            static const unsigned short staticallyStoredValidation[] =
                            {
                            118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0
                            };
                            data = staticallyStoredValidation;
                            length = 10;
                            break;
                        }
                    
                        case ValueOf:
                        {
                            static const unsigned short staticallyStoredValueOf[] =
                            {
                            118, 97, 108, 117, 101, 45, 111, 102, 0
                            };
                            data = staticallyStoredValueOf;
                            length = 8;
                            break;
                        }
                    
                        case Variable:
                        {
                            static const unsigned short staticallyStoredVariable[] =
                            {
                            118, 97, 114, 105, 97, 98, 108, 101, 0
                            };
                            data = staticallyStoredVariable;
                            length = 8;
                            break;
                        }
                    
                        case Version:
                        {
                            static const unsigned short staticallyStoredVersion[] =
                            {
                            118, 101, 114, 115, 105, 111, 110, 0
                            };
                            data = staticallyStoredVersion;
                            length = 7;
                            break;
                        }
                    
                        case When:
                        {
                            static const unsigned short staticallyStoredWhen[] =
                            {
                            119, 104, 101, 110, 0
                            };
                            data = staticallyStoredWhen;
                            length = 4;
                            break;
                        }
                    
                        case WithParam:
                        {
                            static const unsigned short staticallyStoredWithParam[] =
                            {
                            119, 105, 116, 104, 45, 112, 97, 114, 97, 109, 0
                            };
                            data = staticallyStoredWithParam;
                            length = 10;
                            break;
                        }
                    
                        case XpathDefaultNamespace:
                        {
                            static const unsigned short staticallyStoredXpathDefaultNamespace[] =
                            {
                            120, 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 0
                            };
                            data = staticallyStoredXpathDefaultNamespace;
                            length = 23;
                            break;
                        }
                    
                        default:
                            /* It's either the default token, or an undefined enum
                             * value. We silence a compiler warning, and return the
                             * empty string. */
                            ;
                    }

                    union
                    {
                        const unsigned short *data;
                        const QChar *asQChar;
                    } converter;
                    converter.data = data;

                    return QString::fromRawData(converter.asQChar, length);
                }
            
QT_END_NAMESPACE

