var DataState = 0;
var EntityDataState = 1;
var TagOpenState = 2;
var CloseTagOpenState = 3;
var TagNameState = 4;
var BeforeAttributeNameState = 5;
var AttributeNameState = 6;
var AfterAttributeNameState = 7;
var BeforeAttributeValueState = 8;
var AttributeValueDoubleQuotedState = 9;
var AttributeValueSingleQuotedState = 10;
var AttributeValueUnquotedState = 11;
var EntityInAttributeValueState_DoubleQuoted = 12;
var EntityInAttributeValueState_SingleQuoted = 13;
var EntityInAttributeValueState_Unquoted = 14;
var BogusCommentState = 15;
var BogusCommentState_Continue = 16;
var MarkupDeclarationOpenState = 17;
var CommentStartState = 18;
var CommentStartDashState = 19;
var CommentState = 20;
var CommentEndDashState = 21;
var CommentEndState = 22;
var DoctypeState = 23;
var BeforeDoctypeNameState = 24;
var DoctypeNameState = 25;
var AfterDoctypeNameState = 26;
var BeforeDoctypePublicIdentifierState = 27;
var DoctypePublicIdentifierDoubleQuotedState = 28;
var DoctypePublicIdentifierSingleQuotedState = 29;
var AfterDoctypePublicIdentifierState = 30;
var BeforeDoctypeSystemIdentifierState = 31;
var DoctypeSystemIdentifierDoubleQuotedState = 32;
var DoctypeSystemIdentifierSingleQuotedState = 33;
var AfterDoctypeSystemIdentifierState = 34;
var BogusDoctypeState = 35;
var PCDATA = 0;
var RCDATA = 1;
var CDATA = 2;
var PLAINTEXT = 3;
function runTokeniser()
{
    while (true)
    {
        switch (machineState)
        {
        case DataState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 38 && (contentModel == PCDATA || contentModel == RCDATA))
            {
                machineState = EntityDataState;
            }
            else
            if (currentCharacter == 45)
            {
                if ((contentModel == RCDATA || contentModel == CDATA) && !escapeFlag && getOldCharacter(1) == 45 && getOldCharacter(2) == 33 && getOldCharacter(3) == 60)
                {
                    escapeFlag = true;
                    emitCharacterToken(currentCharacter);
                }
                else
                {
                    emitCharacterToken(currentCharacter);
                }
            }
            else
            if (currentCharacter == 60 && contentModel == PCDATA)
            {
                machineState = TagOpenState;
            }
            else
            if (currentCharacter == 60 && (contentModel == RCDATA || contentModel == CDATA) && !escapeFlag)
            {
                machineState = TagOpenState;
            }
            else
            if (currentCharacter == 62)
            {
                if ((contentModel == RCDATA || contentModel == CDATA) && escapeFlag && getOldCharacter(1) == 45 && getOldCharacter(2) == 45)
                {
                    escapeFlag = false;
                    emitCharacterToken(currentCharacter);
                }
                else
                {
                    emitCharacterToken(currentCharacter);
                }
            }
            else
            if (currentCharacter == Char_EOF)
            {
                emitEOFToken();
                return;
            }
            else
            if (true)
            {
                emitCharacterToken(currentCharacter);
            }
            break;
        }
        
        case EntityDataState:
        {
            var hasConsumableEntity_ = hasConsumableEntity(false);
            if (!hasConsumableEntity_)
            {
                emitCharacterToken(38);
                machineState = DataState;
            }
            else
            if (true)
            {
                consumeAndEmitEntity();
                machineState = DataState;
            }
            break;
        }
        
        case TagOpenState:
        {
            currentCharacter = consumeCharacter();
            if (contentModel == RCDATA || contentModel == CDATA)
            {
                if (currentCharacter == 47)
                {
                    machineState = CloseTagOpenState;
                }
                else
                {
                    emitCharacterToken(60);
                    reconsumeCharacter(currentCharacter);
                    machineState = DataState;
                }
            }
            else
            if (contentModel == PCDATA && currentCharacter == 33)
            {
                machineState = MarkupDeclarationOpenState;
            }
            else
            if (contentModel == PCDATA && currentCharacter == 47)
            {
                machineState = CloseTagOpenState;
            }
            else
            if (contentModel == PCDATA && (currentCharacter >= 65 && currentCharacter <= 90))
            {
                createStartTagToken();
                appendToTagTokenName(currentCharacter + 32);
                machineState = TagNameState;
            }
            else
            if (contentModel == PCDATA && (currentCharacter >= 97 && currentCharacter <= 122))
            {
                createStartTagToken();
                appendToTagTokenName(currentCharacter);
                machineState = TagNameState;
            }
            else
            if (contentModel == PCDATA && currentCharacter == 62)
            {
                parseError("Character '>' in TagOpenState");
                emitCharacterToken(60);
                emitCharacterToken(62);
                machineState = DataState;
            }
            else
            if (contentModel == PCDATA && currentCharacter == 63)
            {
                parseError("Character '?' in TagOpenState");
                machineState = BogusCommentState;
            }
            else
            if (contentModel == PCDATA && true)
            {
                parseError("Unexpected character in TagOpenState");
                emitCharacterToken(60);
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            break;
        }
        
        case CloseTagOpenState:
        {
            currentCharacter = consumeCharacter();
            var isEndOfCData_ = isEndOfCData();
            if ((contentModel == RCDATA || contentModel == CDATA) && !isEndOfCData_)
            {
                emitCharacterToken(60);
                emitCharacterToken(47);
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if ((contentModel == PCDATA || isEndOfCData_) && (currentCharacter >= 65 && currentCharacter <= 90))
            {
                createEndTagToken();
                appendToTagTokenName(currentCharacter + 32);
                machineState = TagNameState;
            }
            else
            if ((contentModel == PCDATA || isEndOfCData_) && (currentCharacter >= 97 && currentCharacter <= 122))
            {
                createEndTagToken();
                appendToTagTokenName(currentCharacter);
                machineState = TagNameState;
            }
            else
            if ((contentModel == PCDATA || isEndOfCData_) && currentCharacter == 62)
            {
                parseError("Character '>' in CloseTagOpenState");
                machineState = DataState;
            }
            else
            if ((contentModel == PCDATA || isEndOfCData_) && currentCharacter == Char_EOF)
            {
                parseError("EOF in CloseTagOpenState");
                emitCharacterToken(60);
                emitCharacterToken(47);
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if ((contentModel == PCDATA || isEndOfCData_) && true)
            {
                parseError("Unexpected character in CloseTagOpenState");
                machineState = BogusCommentState;
            }
            break;
        }
        
        case TagNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
                machineState = BeforeAttributeNameState;
            }
            else
            if (currentCharacter == 62)
            {
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                machineState = DataState;
            }
            else
            if (currentCharacter >= 65 && currentCharacter <= 90)
            {
                appendToTagTokenName(currentCharacter + 32);
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in TagNameState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (currentCharacter == 47)
            {
                parseErrorIfNonpermittedSlash();
                machineState = BeforeAttributeNameState;
            }
            else
            if (true)
            {
                appendToTagTokenName(currentCharacter);
            }
            break;
        }
        
        case BeforeAttributeNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 62)
            {
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                machineState = DataState;
            }
            else
            if (currentCharacter >= 65 && currentCharacter <= 90)
            {
                createTagTokenAttribute();
                appendToTagTokenAttributeName(currentCharacter + 32);
                machineState = AttributeNameState;
            }
            else
            if (currentCharacter == 47)
            {
                parseErrorIfNonpermittedSlash();
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in BeforeAttributeNameState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                createTagTokenAttribute();
                appendToTagTokenAttributeName(currentCharacter);
                machineState = AttributeNameState;
            }
            break;
        }
        
        case AttributeNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
                handleDuplicateAttributes();
                machineState = AfterAttributeNameState;
            }
            else
            if (currentCharacter == 61)
            {
                handleDuplicateAttributes();
                machineState = BeforeAttributeValueState;
            }
            else
            if (currentCharacter == 62)
            {
                handleDuplicateAttributes();
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                machineState = DataState;
            }
            else
            if (currentCharacter >= 65 && currentCharacter <= 90)
            {
                appendToTagTokenAttributeName(currentCharacter + 32);
            }
            else
            if (currentCharacter == 47)
            {
                parseErrorIfNonpermittedSlash();
                handleDuplicateAttributes();
                machineState = BeforeAttributeNameState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AttributeNameState");
                handleDuplicateAttributes();
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToTagTokenAttributeName(currentCharacter);
            }
            break;
        }
        
        case AfterAttributeNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 61)
            {
                machineState = BeforeAttributeValueState;
            }
            else
            if (currentCharacter == 62)
            {
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                machineState = DataState;
            }
            else
            if (currentCharacter >= 65 && currentCharacter <= 90)
            {
                createTagTokenAttribute();
                appendToTagTokenAttributeName(currentCharacter + 32);
                machineState = AttributeNameState;
            }
            else
            if (currentCharacter == 47)
            {
                parseErrorIfNonpermittedSlash();
                machineState = BeforeAttributeNameState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AfterAttributeNameState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                createTagTokenAttribute();
                appendToTagTokenAttributeName(currentCharacter);
                machineState = AttributeNameState;
            }
            break;
        }
        
        case BeforeAttributeValueState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 34)
            {
                machineState = AttributeValueDoubleQuotedState;
            }
            else
            if (currentCharacter == 38)
            {
                reconsumeCharacter(currentCharacter);
                machineState = AttributeValueUnquotedState;
            }
            else
            if (currentCharacter == 39)
            {
                machineState = AttributeValueSingleQuotedState;
            }
            else
            if (currentCharacter == 62)
            {
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in BeforeAttributeValueState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToTagTokenAttributeValue(currentCharacter);
                machineState = AttributeValueUnquotedState;
            }
            break;
        }
        
        case AttributeValueDoubleQuotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 34)
            {
                machineState = BeforeAttributeNameState;
            }
            else
            if (currentCharacter == 38)
            {
                machineState = EntityInAttributeValueState_DoubleQuoted;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AttributeValueDoubleQuotedState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToTagTokenAttributeValue(currentCharacter);
            }
            break;
        }
        
        case AttributeValueSingleQuotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 39)
            {
                machineState = BeforeAttributeNameState;
            }
            else
            if (currentCharacter == 38)
            {
                machineState = EntityInAttributeValueState_SingleQuoted;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AttributeValueSingleQuotedState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToTagTokenAttributeValue(currentCharacter);
            }
            break;
        }
        
        case AttributeValueUnquotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
                machineState = BeforeAttributeNameState;
            }
            else
            if (currentCharacter == 38)
            {
                machineState = EntityInAttributeValueState_Unquoted;
            }
            else
            if (currentCharacter == 62)
            {
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AttributeValueUnquotedState");
                parseErrorIfEndTagWithAttributes();
                emitCurrentTagToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToTagTokenAttributeValue(currentCharacter);
            }
            break;
        }
        
        case EntityInAttributeValueState_DoubleQuoted:
        {
            var hasConsumableEntity_ = hasConsumableEntity(true);
            if (!hasConsumableEntity_)
            {
                appendToTagTokenAttributeValue(38);
                machineState = AttributeValueDoubleQuotedState;
            }
            else
            if (true)
            {
                consumeAndAppendEntity();
                machineState = AttributeValueDoubleQuotedState;
            }
            break;
        }
        
        case EntityInAttributeValueState_SingleQuoted:
        {
            var hasConsumableEntity_ = hasConsumableEntity(true);
            if (!hasConsumableEntity_)
            {
                appendToTagTokenAttributeValue(38);
                machineState = AttributeValueSingleQuotedState;
            }
            else
            if (true)
            {
                consumeAndAppendEntity();
                machineState = AttributeValueSingleQuotedState;
            }
            break;
        }
        
        case EntityInAttributeValueState_Unquoted:
        {
            var hasConsumableEntity_ = hasConsumableEntity(true);
            if (!hasConsumableEntity_)
            {
                appendToTagTokenAttributeValue(38);
                machineState = AttributeValueUnquotedState;
            }
            else
            if (true)
            {
                consumeAndAppendEntity();
                machineState = AttributeValueUnquotedState;
            }
            break;
        }
        
        case BogusCommentState:
        {
            if (currentCharacter == Char_EOF)
            {
                createCommentToken();
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (currentCharacter == 62)
            {
                createCommentToken();
                emitCurrentCommentToken();
                machineState = DataState;
            }
            else
            if (!(currentCharacter == Char_EOF || currentCharacter == 62))
            {
                createCommentToken();
                appendToCommentToken(currentCharacter);
                machineState = BogusCommentState_Continue;
            }
            break;
        }
        
        case BogusCommentState_Continue:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == Char_EOF)
            {
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (currentCharacter == 62)
            {
                emitCurrentCommentToken();
                machineState = DataState;
            }
            else
            if (!(currentCharacter == Char_EOF || currentCharacter == 62))
            {
                appendToCommentToken(currentCharacter);
            }
            break;
        }
        
        case MarkupDeclarationOpenState:
        {
            currentCharacter = consumeCharacter();
            if (isFollowedBy("--"))
            {
                currentCharacter = consumeCharacter();
                createCommentToken();
                machineState = CommentStartState;
            }
            else
            if (!(isFollowedBy("--")) && isFollowedBy("doctype"))
            {
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                machineState = DoctypeState;
            }
            else
            if (!(isFollowedBy("--") || isFollowedBy("doctype")))
            {
                parseError("Unexpected character in MarkupDeclarationOpenState");
                machineState = BogusCommentState;
            }
            break;
        }
        
        case CommentStartState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 45)
            {
                machineState = CommentStartDashState;
            }
            else
            if (currentCharacter == 62)
            {
                parseError("Character '>' in CommentStartState");
                emitCurrentCommentToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in CommentStartState");
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToCommentToken(currentCharacter);
                machineState = CommentState;
            }
            break;
        }
        
        case CommentStartDashState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 45)
            {
                machineState = CommentEndState;
            }
            else
            if (currentCharacter == 62)
            {
                parseError("Character '>' in CommentStartDashState");
                emitCurrentCommentToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in CommentStartDashState");
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToCommentToken(45);
                appendToCommentToken(currentCharacter);
                machineState = CommentState;
            }
            break;
        }
        
        case CommentState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 45)
            {
                machineState = CommentEndDashState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in CommentState");
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToCommentToken(currentCharacter);
            }
            break;
        }
        
        case CommentEndDashState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 45)
            {
                machineState = CommentEndState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in CommentEndDashState");
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToCommentToken(45);
                appendToCommentToken(currentCharacter);
                machineState = CommentState;
            }
            break;
        }
        
        case CommentEndState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 62)
            {
                emitCurrentCommentToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == 45)
            {
                parseError("Character '-' in CommentEndState");
                appendToCommentToken(45);
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in CommentEndState");
                emitCurrentCommentToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in CommentEndState");
                appendToCommentToken(45);
                appendToCommentToken(45);
                appendToCommentToken(currentCharacter);
                machineState = CommentState;
            }
            break;
        }
        
        case DoctypeState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
                machineState = BeforeDoctypeNameState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in DoctypeState");
                reconsumeCharacter(currentCharacter);
                machineState = BeforeDoctypeNameState;
            }
            break;
        }
        
        case BeforeDoctypeNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 62)
            {
                parseError("Character '>' in BeforeDoctypeNameState");
                createDoctypeToken();
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in BeforeDoctypeNameState");
                createDoctypeToken();
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                createDoctypeToken();
                appendToDoctypeTokenName(currentCharacter);
                machineState = DoctypeNameState;
            }
            break;
        }
        
        case DoctypeNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
                machineState = AfterDoctypeNameState;
            }
            else
            if (currentCharacter == 62)
            {
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in DoctypeNameState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToDoctypeTokenName(currentCharacter);
            }
            break;
        }
        
        case AfterDoctypeNameState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 62)
            {
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AfterDoctypeNameState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (isFollowedBy("public"))
            {
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                machineState = BeforeDoctypePublicIdentifierState;
            }
            else
            if (isFollowedBy("system"))
            {
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                currentCharacter = consumeCharacter();
                machineState = BeforeDoctypeSystemIdentifierState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in AfterDoctypeNameState");
                machineState = BogusDoctypeState;
            }
            break;
        }
        
        case BeforeDoctypePublicIdentifierState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 34)
            {
                setDoctypeTokenPubIdEmpty();
                machineState = DoctypePublicIdentifierDoubleQuotedState;
            }
            else
            if (currentCharacter == 39)
            {
                setDoctypeTokenPubIdEmpty();
                machineState = DoctypePublicIdentifierSingleQuotedState;
            }
            else
            if (currentCharacter == 62)
            {
                parseError("Character '>' in BeforeDoctypePublicIdentifierState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in BeforeDoctypePublicIdentifierState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in BeforeDoctypePublicIdentifierState");
                machineState = BogusDoctypeState;
            }
            break;
        }
        
        case DoctypePublicIdentifierDoubleQuotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 34)
            {
                machineState = AfterDoctypePublicIdentifierState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in DoctypePublicIdentifierDoubleQuotedState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToDoctypeTokenPubId(currentCharacter);
            }
            break;
        }
        
        case DoctypePublicIdentifierSingleQuotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 39)
            {
                machineState = AfterDoctypePublicIdentifierState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in DoctypePublicIdentifierSingleQuotedState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToDoctypeTokenPubId(currentCharacter);
            }
            break;
        }
        
        case AfterDoctypePublicIdentifierState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 34)
            {
                setDoctypeTokenSysIdEmpty();
                machineState = DoctypeSystemIdentifierDoubleQuotedState;
            }
            else
            if (currentCharacter == 39)
            {
                setDoctypeTokenSysIdEmpty();
                machineState = DoctypeSystemIdentifierSingleQuotedState;
            }
            else
            if (currentCharacter == 62)
            {
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AfterDoctypePublicIdentifierState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in AfterDoctypePublicIdentifierState");
                machineState = BogusDoctypeState;
            }
            break;
        }
        
        case BeforeDoctypeSystemIdentifierState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 34)
            {
                setDoctypeTokenSysIdEmpty();
                machineState = DoctypeSystemIdentifierDoubleQuotedState;
            }
            else
            if (currentCharacter == 39)
            {
                setDoctypeTokenSysIdEmpty();
                machineState = DoctypeSystemIdentifierSingleQuotedState;
            }
            else
            if (currentCharacter == 62)
            {
                parseError("Character '>' in BeforeDoctypeSystemIdentifierState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in BeforeDoctypeSystemIdentifierState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in BeforeDoctypeSystemIdentifierState");
                machineState = BogusDoctypeState;
            }
            break;
        }
        
        case DoctypeSystemIdentifierDoubleQuotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 34)
            {
                machineState = AfterDoctypeSystemIdentifierState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in DoctypeSystemIdentifierDoubleQuotedState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToDoctypeTokenSysId(currentCharacter);
            }
            break;
        }
        
        case DoctypeSystemIdentifierSingleQuotedState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 39)
            {
                machineState = AfterDoctypeSystemIdentifierState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in DoctypeSystemIdentifierSingleQuotedState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                appendToDoctypeTokenSysId(currentCharacter);
            }
            break;
        }
        
        case AfterDoctypeSystemIdentifierState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 9 || currentCharacter == 10 || currentCharacter == 11 || currentCharacter == 12 || currentCharacter == 32)
            {
            }
            else
            if (currentCharacter == 62)
            {
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in AfterDoctypeSystemIdentifierState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
                parseError("Unexpected character in AfterDoctypeSystemIdentifierState");
                machineState = BogusDoctypeState;
            }
            break;
        }
        
        case BogusDoctypeState:
        {
            currentCharacter = consumeCharacter();
            if (currentCharacter == 62)
            {
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                machineState = DataState;
            }
            else
            if (currentCharacter == Char_EOF)
            {
                parseError("EOF in BogusDoctypeState");
                setDoctypeTokenIncorrect();
                emitCurrentDoctypeToken();
                reconsumeCharacter(currentCharacter);
                machineState = DataState;
            }
            else
            if (true)
            {
            }
            break;
        }
        
        }
    }
}