# Generated from scriptingLanguage.g4 by ANTLR 4.7.1
# encoding: utf-8
from __future__ import print_function
from antlr4 import *
from io import StringIO
import sys

def serializedATN():
    with StringIO() as buf:
        buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
        buf.write(u"M\u02fa\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
        buf.write(u"\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
        buf.write(u"\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4")
        buf.write(u"\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30")
        buf.write(u"\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t")
        buf.write(u"\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$")
        buf.write(u"\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t")
        buf.write(u",\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63")
        buf.write(u"\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\4")
        buf.write(u"9\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA")
        buf.write(u"\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\t")
        buf.write(u"J\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S")
        buf.write(u"\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\3")
        buf.write(u"\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3")
        buf.write(u"\4\3\4\3\4\6\4\u00c7\n\4\r\4\16\4\u00c8\3\5\3\5\5\5\u00cd")
        buf.write(u"\n\5\3\6\3\6\5\6\u00d1\n\6\3\7\3\7\5\7\u00d5\n\7\3\b")
        buf.write(u"\3\b\5\b\u00d9\n\b\3\t\3\t\5\t\u00dd\n\t\3\n\3\n\5\n")
        buf.write(u"\u00e1\n\n\3\13\3\13\5\13\u00e5\n\13\3\f\3\f\5\f\u00e9")
        buf.write(u"\n\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3")
        buf.write(u"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17")
        buf.write(u"\3\17\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3")
        buf.write(u"\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21")
        buf.write(u"\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\3")
        buf.write(u"\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
        buf.write(u"\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3")
        buf.write(u"\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3")
        buf.write(u"\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30")
        buf.write(u"\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3")
        buf.write(u"\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32")
        buf.write(u"\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3")
        buf.write(u"\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34")
        buf.write(u"\3\34\3\34\3\34\3\34\3\35\3\35\3\36\3\36\3\36\3\36\3")
        buf.write(u"\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36")
        buf.write(u"\3\36\3\36\5\36\u0196\n\36\3\36\3\36\6\36\u019a\n\36")
        buf.write(u"\r\36\16\36\u019b\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!")
        buf.write(u"\3!\3!\3\"\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3%\3%\3%\3&")
        buf.write(u"\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'")
        buf.write(u"\3\'\3\'\5\'\u01c7\n\'\3\'\3\'\6\'\u01cb\n\'\r\'\16\'")
        buf.write(u"\u01cc\3(\3(\3(\3)\3)\3)\3*\3*\3*\3+\3+\3+\3+\3+\3+\3")
        buf.write(u"+\3+\3+\3+\3+\3+\3+\5+\u01e5\n+\3+\3+\6+\u01e9\n+\r+")
        buf.write(u"\16+\u01ea\3,\3,\3,\3,\3-\3-\3-\3-\3.\3.\3.\3/\3/\3/")
        buf.write(u"\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3")
        buf.write(u"\60\3\60\3\60\3\60\3\60\3\60\5\60\u020b\n\60\3\60\3\60")
        buf.write(u"\6\60\u020f\n\60\r\60\16\60\u0210\3\61\3\61\3\61\3\61")
        buf.write(u"\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\64\3")
        buf.write(u"\64\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67")
        buf.write(u"\3\67\38\38\38\38\38\38\38\38\38\38\38\38\38\58\u023a")
        buf.write(u"\n8\38\38\68\u023e\n8\r8\168\u023f\39\39\39\3:\3:\3:")
        buf.write(u"\3;\3;\3;\3<\3<\3<\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write(u"=\5=\u025a\n=\3=\3=\6=\u025e\n=\r=\16=\u025f\3>\3>\3")
        buf.write(u">\3>\3?\3?\3?\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A")
        buf.write(u"\3A\3A\3A\3A\3A\3A\5A\u027c\nA\3A\3A\6A\u0280\nA\rA\16")
        buf.write(u"A\u0281\3B\3B\3B\3B\3C\3C\3C\3D\3D\3D\3E\3E\3E\3F\3F")
        buf.write(u"\3F\3G\3G\3G\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3")
        buf.write(u"I\3I\3I\3I\3I\5I\u02a9\nI\3I\3I\6I\u02ad\nI\rI\16I\u02ae")
        buf.write(u"\3J\3J\3J\3J\3K\3K\3K\3L\3L\3L\3M\3M\3M\3N\3N\3N\3O\3")
        buf.write(u"O\3O\3O\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3R")
        buf.write(u"\3R\3R\3R\3S\3S\3S\3S\3S\3T\3T\3T\3T\3U\3U\3U\3U\3U\3")
        buf.write(u"U\3V\3V\3V\3V\3V\3W\3W\3W\3X\3X\3X\3X\5X\u02f2\nX\3Y")
        buf.write(u"\3Y\3Z\3Z\3[\3[\3[\2\2\\\2\4\6\b\n\f\16\20\22\24\26\30")
        buf.write(u"\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`")
        buf.write(u"bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
        buf.write(u"\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
        buf.write(u"\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0")
        buf.write(u"\u00b2\u00b4\2\4\3\28A\3\2BI\2\u0322\2\u00b6\3\2\2\2")
        buf.write(u"\4\u00bc\3\2\2\2\6\u00c6\3\2\2\2\b\u00cc\3\2\2\2\n\u00d0")
        buf.write(u"\3\2\2\2\f\u00d4\3\2\2\2\16\u00d8\3\2\2\2\20\u00dc\3")
        buf.write(u"\2\2\2\22\u00e0\3\2\2\2\24\u00e4\3\2\2\2\26\u00e8\3\2")
        buf.write(u"\2\2\30\u00ea\3\2\2\2\32\u00f3\3\2\2\2\34\u00fd\3\2\2")
        buf.write(u"\2\36\u0106\3\2\2\2 \u0110\3\2\2\2\"\u0119\3\2\2\2$\u0123")
        buf.write(u"\3\2\2\2&\u012c\3\2\2\2(\u0136\3\2\2\2*\u013f\3\2\2\2")
        buf.write(u",\u0149\3\2\2\2.\u0152\3\2\2\2\60\u015c\3\2\2\2\62\u0165")
        buf.write(u"\3\2\2\2\64\u016f\3\2\2\2\66\u0178\3\2\2\28\u0182\3\2")
        buf.write(u"\2\2:\u0199\3\2\2\2<\u019d\3\2\2\2>\u01a1\3\2\2\2@\u01a5")
        buf.write(u"\3\2\2\2B\u01a8\3\2\2\2D\u01ac\3\2\2\2F\u01af\3\2\2\2")
        buf.write(u"H\u01b2\3\2\2\2J\u01b5\3\2\2\2L\u01ca\3\2\2\2N\u01ce")
        buf.write(u"\3\2\2\2P\u01d1\3\2\2\2R\u01d4\3\2\2\2T\u01e8\3\2\2\2")
        buf.write(u"V\u01ec\3\2\2\2X\u01f0\3\2\2\2Z\u01f4\3\2\2\2\\\u01f7")
        buf.write(u"\3\2\2\2^\u020e\3\2\2\2`\u0212\3\2\2\2b\u0216\3\2\2\2")
        buf.write(u"d\u021a\3\2\2\2f\u021f\3\2\2\2h\u0223\3\2\2\2j\u0226")
        buf.write(u"\3\2\2\2l\u0229\3\2\2\2n\u023d\3\2\2\2p\u0241\3\2\2\2")
        buf.write(u"r\u0244\3\2\2\2t\u0247\3\2\2\2v\u024a\3\2\2\2x\u025d")
        buf.write(u"\3\2\2\2z\u0261\3\2\2\2|\u0265\3\2\2\2~\u0268\3\2\2\2")
        buf.write(u"\u0080\u027f\3\2\2\2\u0082\u0283\3\2\2\2\u0084\u0287")
        buf.write(u"\3\2\2\2\u0086\u028a\3\2\2\2\u0088\u028d\3\2\2\2\u008a")
        buf.write(u"\u0290\3\2\2\2\u008c\u0293\3\2\2\2\u008e\u0296\3\2\2")
        buf.write(u"\2\u0090\u02ac\3\2\2\2\u0092\u02b0\3\2\2\2\u0094\u02b4")
        buf.write(u"\3\2\2\2\u0096\u02b7\3\2\2\2\u0098\u02ba\3\2\2\2\u009a")
        buf.write(u"\u02bd\3\2\2\2\u009c\u02c0\3\2\2\2\u009e\u02c4\3\2\2")
        buf.write(u"\2\u00a0\u02c9\3\2\2\2\u00a2\u02d2\3\2\2\2\u00a4\u02d6")
        buf.write(u"\3\2\2\2\u00a6\u02db\3\2\2\2\u00a8\u02df\3\2\2\2\u00aa")
        buf.write(u"\u02e5\3\2\2\2\u00ac\u02ea\3\2\2\2\u00ae\u02ed\3\2\2")
        buf.write(u"\2\u00b0\u02f3\3\2\2\2\u00b2\u02f5\3\2\2\2\u00b4\u02f7")
        buf.write(u"\3\2\2\2\u00b6\u00b7\7\3\2\2\u00b7\u00b8\5\4\3\2\u00b8")
        buf.write(u"\u00b9\7\4\2\2\u00b9\u00ba\7\5\2\2\u00ba\u00bb\5\6\4")
        buf.write(u"\2\u00bb\3\3\2\2\2\u00bc\u00bd\t\2\2\2\u00bd\5\3\2\2")
        buf.write(u"\2\u00be\u00c7\5\b\5\2\u00bf\u00c7\5\n\6\2\u00c0\u00c7")
        buf.write(u"\5\f\7\2\u00c1\u00c7\5\16\b\2\u00c2\u00c7\5\20\t\2\u00c3")
        buf.write(u"\u00c7\5\22\n\2\u00c4\u00c7\5\24\13\2\u00c5\u00c7\5\26")
        buf.write(u"\f\2\u00c6\u00be\3\2\2\2\u00c6\u00bf\3\2\2\2\u00c6\u00c0")
        buf.write(u"\3\2\2\2\u00c6\u00c1\3\2\2\2\u00c6\u00c2\3\2\2\2\u00c6")
        buf.write(u"\u00c3\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c5\3\2\2")
        buf.write(u"\2\u00c7\u00c8\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c9")
        buf.write(u"\3\2\2\2\u00c9\7\3\2\2\2\u00ca\u00cd\5\30\r\2\u00cb\u00cd")
        buf.write(u"\5\32\16\2\u00cc\u00ca\3\2\2\2\u00cc\u00cb\3\2\2\2\u00cd")
        buf.write(u"\t\3\2\2\2\u00ce\u00d1\5\34\17\2\u00cf\u00d1\5\36\20")
        buf.write(u"\2\u00d0\u00ce\3\2\2\2\u00d0\u00cf\3\2\2\2\u00d1\13\3")
        buf.write(u"\2\2\2\u00d2\u00d5\5 \21\2\u00d3\u00d5\5\"\22\2\u00d4")
        buf.write(u"\u00d2\3\2\2\2\u00d4\u00d3\3\2\2\2\u00d5\r\3\2\2\2\u00d6")
        buf.write(u"\u00d9\5$\23\2\u00d7\u00d9\5&\24\2\u00d8\u00d6\3\2\2")
        buf.write(u"\2\u00d8\u00d7\3\2\2\2\u00d9\17\3\2\2\2\u00da\u00dd\5")
        buf.write(u"(\25\2\u00db\u00dd\5*\26\2\u00dc\u00da\3\2\2\2\u00dc")
        buf.write(u"\u00db\3\2\2\2\u00dd\21\3\2\2\2\u00de\u00e1\5,\27\2\u00df")
        buf.write(u"\u00e1\5.\30\2\u00e0\u00de\3\2\2\2\u00e0\u00df\3\2\2")
        buf.write(u"\2\u00e1\23\3\2\2\2\u00e2\u00e5\5\60\31\2\u00e3\u00e5")
        buf.write(u"\5\62\32\2\u00e4\u00e2\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5")
        buf.write(u"\25\3\2\2\2\u00e6\u00e9\5\64\33\2\u00e7\u00e9\5\66\34")
        buf.write(u"\2\u00e8\u00e6\3\2\2\2\u00e8\u00e7\3\2\2\2\u00e9\27\3")
        buf.write(u"\2\2\2\u00ea\u00eb\7\7\2\2\u00eb\u00ec\7B\2\2\u00ec\u00ed")
        buf.write(u"\7\b\2\2\u00ed\u00ee\7\t\2\2\u00ee\u00ef\7\n\2\2\u00ef")
        buf.write(u"\u00f0\7\f\2\2\u00f0\u00f1\7\5\2\2\u00f1\u00f2\5:\36")
        buf.write(u"\2\u00f2\31\3\2\2\2\u00f3\u00f4\7\7\2\2\u00f4\u00f5\7")
        buf.write(u"B\2\2\u00f5\u00f6\7\b\2\2\u00f6\u00f7\7\t\2\2\u00f7\u00f8")
        buf.write(u"\7\13\2\2\u00f8\u00f9\7\f\2\2\u00f9\u00fa\58\35\2\u00fa")
        buf.write(u"\u00fb\7\5\2\2\u00fb\u00fc\5:\36\2\u00fc\33\3\2\2\2\u00fd")
        buf.write(u"\u00fe\7\7\2\2\u00fe\u00ff\7C\2\2\u00ff\u0100\7\b\2\2")
        buf.write(u"\u0100\u0101\7\t\2\2\u0101\u0102\7\n\2\2\u0102\u0103")
        buf.write(u"\7\f\2\2\u0103\u0104\7\5\2\2\u0104\u0105\5L\'\2\u0105")
        buf.write(u"\35\3\2\2\2\u0106\u0107\7\7\2\2\u0107\u0108\7C\2\2\u0108")
        buf.write(u"\u0109\7\b\2\2\u0109\u010a\7\t\2\2\u010a\u010b\7\13\2")
        buf.write(u"\2\u010b\u010c\7\f\2\2\u010c\u010d\58\35\2\u010d\u010e")
        buf.write(u"\7\5\2\2\u010e\u010f\5L\'\2\u010f\37\3\2\2\2\u0110\u0111")
        buf.write(u"\7\7\2\2\u0111\u0112\7D\2\2\u0112\u0113\7\b\2\2\u0113")
        buf.write(u"\u0114\7\t\2\2\u0114\u0115\7\n\2\2\u0115\u0116\7\f\2")
        buf.write(u"\2\u0116\u0117\7\5\2\2\u0117\u0118\5T+\2\u0118!\3\2\2")
        buf.write(u"\2\u0119\u011a\7\7\2\2\u011a\u011b\7D\2\2\u011b\u011c")
        buf.write(u"\7\b\2\2\u011c\u011d\7\t\2\2\u011d\u011e\7\13\2\2\u011e")
        buf.write(u"\u011f\7\f\2\2\u011f\u0120\58\35\2\u0120\u0121\7\5\2")
        buf.write(u"\2\u0121\u0122\5T+\2\u0122#\3\2\2\2\u0123\u0124\7\7\2")
        buf.write(u"\2\u0124\u0125\7E\2\2\u0125\u0126\7\b\2\2\u0126\u0127")
        buf.write(u"\7\t\2\2\u0127\u0128\7\n\2\2\u0128\u0129\7\f\2\2\u0129")
        buf.write(u"\u012a\7\5\2\2\u012a\u012b\5^\60\2\u012b%\3\2\2\2\u012c")
        buf.write(u"\u012d\7\7\2\2\u012d\u012e\7E\2\2\u012e\u012f\7\b\2\2")
        buf.write(u"\u012f\u0130\7\t\2\2\u0130\u0131\7\13\2\2\u0131\u0132")
        buf.write(u"\7\f\2\2\u0132\u0133\58\35\2\u0133\u0134\7\5\2\2\u0134")
        buf.write(u"\u0135\5^\60\2\u0135\'\3\2\2\2\u0136\u0137\7\7\2\2\u0137")
        buf.write(u"\u0138\7F\2\2\u0138\u0139\7\b\2\2\u0139\u013a\7\t\2\2")
        buf.write(u"\u013a\u013b\7\n\2\2\u013b\u013c\7\f\2\2\u013c\u013d")
        buf.write(u"\7\5\2\2\u013d\u013e\5n8\2\u013e)\3\2\2\2\u013f\u0140")
        buf.write(u"\7\7\2\2\u0140\u0141\7F\2\2\u0141\u0142\7\b\2\2\u0142")
        buf.write(u"\u0143\7\t\2\2\u0143\u0144\7\13\2\2\u0144\u0145\7\f\2")
        buf.write(u"\2\u0145\u0146\58\35\2\u0146\u0147\7\5\2\2\u0147\u0148")
        buf.write(u"\5n8\2\u0148+\3\2\2\2\u0149\u014a\7\7\2\2\u014a\u014b")
        buf.write(u"\7G\2\2\u014b\u014c\7\b\2\2\u014c\u014d\7\t\2\2\u014d")
        buf.write(u"\u014e\7\n\2\2\u014e\u014f\7\f\2\2\u014f\u0150\7\5\2")
        buf.write(u"\2\u0150\u0151\5x=\2\u0151-\3\2\2\2\u0152\u0153\7\7\2")
        buf.write(u"\2\u0153\u0154\7G\2\2\u0154\u0155\7\b\2\2\u0155\u0156")
        buf.write(u"\7\t\2\2\u0156\u0157\7\13\2\2\u0157\u0158\7\f\2\2\u0158")
        buf.write(u"\u0159\58\35\2\u0159\u015a\7\5\2\2\u015a\u015b\5x=\2")
        buf.write(u"\u015b/\3\2\2\2\u015c\u015d\7\7\2\2\u015d\u015e\7H\2")
        buf.write(u"\2\u015e\u015f\7\b\2\2\u015f\u0160\7\t\2\2\u0160\u0161")
        buf.write(u"\7\n\2\2\u0161\u0162\7\f\2\2\u0162\u0163\7\5\2\2\u0163")
        buf.write(u"\u0164\5\u0080A\2\u0164\61\3\2\2\2\u0165\u0166\7\7\2")
        buf.write(u"\2\u0166\u0167\7H\2\2\u0167\u0168\7\b\2\2\u0168\u0169")
        buf.write(u"\7\t\2\2\u0169\u016a\7\13\2\2\u016a\u016b\7\f\2\2\u016b")
        buf.write(u"\u016c\58\35\2\u016c\u016d\7\5\2\2\u016d\u016e\5\u0080")
        buf.write(u"A\2\u016e\63\3\2\2\2\u016f\u0170\7\7\2\2\u0170\u0171")
        buf.write(u"\7I\2\2\u0171\u0172\7\b\2\2\u0172\u0173\7\t\2\2\u0173")
        buf.write(u"\u0174\7\n\2\2\u0174\u0175\7\f\2\2\u0175\u0176\7\5\2")
        buf.write(u"\2\u0176\u0177\5\u0090I\2\u0177\65\3\2\2\2\u0178\u0179")
        buf.write(u"\7\7\2\2\u0179\u017a\7I\2\2\u017a\u017b\7\b\2\2\u017b")
        buf.write(u"\u017c\7\t\2\2\u017c\u017d\7\13\2\2\u017d\u017e\7\f\2")
        buf.write(u"\2\u017e\u017f\58\35\2\u017f\u0180\7\5\2\2\u0180\u0181")
        buf.write(u"\5\u0090I\2\u0181\67\3\2\2\2\u0182\u0183\t\3\2\2\u0183")
        buf.write(u"9\3\2\2\2\u0184\u0196\5<\37\2\u0185\u0196\5> \2\u0186")
        buf.write(u"\u0196\5@!\2\u0187\u0196\5B\"\2\u0188\u0196\5D#\2\u0189")
        buf.write(u"\u0196\5F$\2\u018a\u0196\5H%\2\u018b\u0196\5J&\2\u018c")
        buf.write(u"\u0196\5\u009cO\2\u018d\u0196\5\u009eP\2\u018e\u0196")
        buf.write(u"\5\u00a0Q\2\u018f\u0196\5\u00a2R\2\u0190\u0196\5\u00a4")
        buf.write(u"S\2\u0191\u0196\5\u00a6T\2\u0192\u0196\5\u00aeX\2\u0193")
        buf.write(u"\u0196\5\u00a8U\2\u0194\u0196\5\u00aaV\2\u0195\u0184")
        buf.write(u"\3\2\2\2\u0195\u0185\3\2\2\2\u0195\u0186\3\2\2\2\u0195")
        buf.write(u"\u0187\3\2\2\2\u0195\u0188\3\2\2\2\u0195\u0189\3\2\2")
        buf.write(u"\2\u0195\u018a\3\2\2\2\u0195\u018b\3\2\2\2\u0195\u018c")
        buf.write(u"\3\2\2\2\u0195\u018d\3\2\2\2\u0195\u018e\3\2\2\2\u0195")
        buf.write(u"\u018f\3\2\2\2\u0195\u0190\3\2\2\2\u0195\u0191\3\2\2")
        buf.write(u"\2\u0195\u0192\3\2\2\2\u0195\u0193\3\2\2\2\u0195\u0194")
        buf.write(u"\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198\7\6\2\2\u0198")
        buf.write(u"\u019a\3\2\2\2\u0199\u0195\3\2\2\2\u019a\u019b\3\2\2")
        buf.write(u"\2\u019b\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c;\3\2")
        buf.write(u"\2\2\u019d\u019e\7$\2\2\u019e\u019f\7%\2\2\u019f\u01a0")
        buf.write(u"\7J\2\2\u01a0=\3\2\2\2\u01a1\u01a2\7#\2\2\u01a2\u01a3")
        buf.write(u"\7\25\2\2\u01a3\u01a4\7M\2\2\u01a4?\3\2\2\2\u01a5\u01a6")
        buf.write(u"\7#\2\2\u01a6\u01a7\7\27\2\2\u01a7A\3\2\2\2\u01a8\u01a9")
        buf.write(u"\7\20\2\2\u01a9\u01aa\7\25\2\2\u01aa\u01ab\7M\2\2\u01ab")
        buf.write(u"C\3\2\2\2\u01ac\u01ad\7\23\2\2\u01ad\u01ae\7\24\2\2\u01ae")
        buf.write(u"E\3\2\2\2\u01af\u01b0\7\34\2\2\u01b0\u01b1\7\35\2\2\u01b1")
        buf.write(u"G\3\2\2\2\u01b2\u01b3\7\34\2\2\u01b3\u01b4\7\36\2\2\u01b4")
        buf.write(u"I\3\2\2\2\u01b5\u01b6\7\62\2\2\u01b6\u01b7\7\63\2\2\u01b7")
        buf.write(u"\u01b8\7\64\2\2\u01b8\u01b9\7M\2\2\u01b9K\3\2\2\2\u01ba")
        buf.write(u"\u01c7\5N(\2\u01bb\u01c7\5P)\2\u01bc\u01c7\5R*\2\u01bd")
        buf.write(u"\u01c7\5\u009cO\2\u01be\u01c7\5\u009eP\2\u01bf\u01c7")
        buf.write(u"\5\u00a0Q\2\u01c0\u01c7\5\u00a2R\2\u01c1\u01c7\5\u00a4")
        buf.write(u"S\2\u01c2\u01c7\5\u00a6T\2\u01c3\u01c7\5\u00aeX\2\u01c4")
        buf.write(u"\u01c7\5\u00a8U\2\u01c5\u01c7\5\u00aaV\2\u01c6\u01ba")
        buf.write(u"\3\2\2\2\u01c6\u01bb\3\2\2\2\u01c6\u01bc\3\2\2\2\u01c6")
        buf.write(u"\u01bd\3\2\2\2\u01c6\u01be\3\2\2\2\u01c6\u01bf\3\2\2")
        buf.write(u"\2\u01c6\u01c0\3\2\2\2\u01c6\u01c1\3\2\2\2\u01c6\u01c2")
        buf.write(u"\3\2\2\2\u01c6\u01c3\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6")
        buf.write(u"\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\7\6\2")
        buf.write(u"\2\u01c9\u01cb\3\2\2\2\u01ca\u01c6\3\2\2\2\u01cb\u01cc")
        buf.write(u"\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd")
        buf.write(u"M\3\2\2\2\u01ce\u01cf\7\20\2\2\u01cf\u01d0\7\22\2\2\u01d0")
        buf.write(u"O\3\2\2\2\u01d1\u01d2\7\20\2\2\u01d2\u01d3\7C\2\2\u01d3")
        buf.write(u"Q\3\2\2\2\u01d4\u01d5\7\23\2\2\u01d5\u01d6\7\24\2\2\u01d6")
        buf.write(u"S\3\2\2\2\u01d7\u01e5\5V,\2\u01d8\u01e5\5X-\2\u01d9\u01e5")
        buf.write(u"\5Z.\2\u01da\u01e5\5\\/\2\u01db\u01e5\5\u009cO\2\u01dc")
        buf.write(u"\u01e5\5\u009eP\2\u01dd\u01e5\5\u00a0Q\2\u01de\u01e5")
        buf.write(u"\5\u00a2R\2\u01df\u01e5\5\u00a4S\2\u01e0\u01e5\5\u00a6")
        buf.write(u"T\2\u01e1\u01e5\5\u00aeX\2\u01e2\u01e5\5\u00a8U\2\u01e3")
        buf.write(u"\u01e5\5\u00aaV\2\u01e4\u01d7\3\2\2\2\u01e4\u01d8\3\2")
        buf.write(u"\2\2\u01e4\u01d9\3\2\2\2\u01e4\u01da\3\2\2\2\u01e4\u01db")
        buf.write(u"\3\2\2\2\u01e4\u01dc\3\2\2\2\u01e4\u01dd\3\2\2\2\u01e4")
        buf.write(u"\u01de\3\2\2\2\u01e4\u01df\3\2\2\2\u01e4\u01e0\3\2\2")
        buf.write(u"\2\u01e4\u01e1\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e4\u01e3")
        buf.write(u"\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\u01e7\7\6\2\2\u01e7")
        buf.write(u"\u01e9\3\2\2\2\u01e8\u01e4\3\2\2\2\u01e9\u01ea\3\2\2")
        buf.write(u"\2\u01ea\u01e8\3\2\2\2\u01ea\u01eb\3\2\2\2\u01ebU\3\2")
        buf.write(u"\2\2\u01ec\u01ed\7\r\2\2\u01ed\u01ee\7\16\2\2\u01ee\u01ef")
        buf.write(u"\7J\2\2\u01efW\3\2\2\2\u01f0\u01f1\7\r\2\2\u01f1\u01f2")
        buf.write(u"\7\17\2\2\u01f2\u01f3\7J\2\2\u01f3Y\3\2\2\2\u01f4\u01f5")
        buf.write(u"\7\20\2\2\u01f5\u01f6\7\21\2\2\u01f6[\3\2\2\2\u01f7\u01f8")
        buf.write(u"\7\66\2\2\u01f8\u01f9\7\67\2\2\u01f9]\3\2\2\2\u01fa\u020b")
        buf.write(u"\5`\61\2\u01fb\u020b\5b\62\2\u01fc\u020b\5d\63\2\u01fd")
        buf.write(u"\u020b\5f\64\2\u01fe\u020b\5h\65\2\u01ff\u020b\5j\66")
        buf.write(u"\2\u0200\u020b\5l\67\2\u0201\u020b\5\u009cO\2\u0202\u020b")
        buf.write(u"\5\u009eP\2\u0203\u020b\5\u00a0Q\2\u0204\u020b\5\u00a2")
        buf.write(u"R\2\u0205\u020b\5\u00a4S\2\u0206\u020b\5\u00a6T\2\u0207")
        buf.write(u"\u020b\5\u00aeX\2\u0208\u020b\5\u00a8U\2\u0209\u020b")
        buf.write(u"\5\u00aaV\2\u020a\u01fa\3\2\2\2\u020a\u01fb\3\2\2\2\u020a")
        buf.write(u"\u01fc\3\2\2\2\u020a\u01fd\3\2\2\2\u020a\u01fe\3\2\2")
        buf.write(u"\2\u020a\u01ff\3\2\2\2\u020a\u0200\3\2\2\2\u020a\u0201")
        buf.write(u"\3\2\2\2\u020a\u0202\3\2\2\2\u020a\u0203\3\2\2\2\u020a")
        buf.write(u"\u0204\3\2\2\2\u020a\u0205\3\2\2\2\u020a\u0206\3\2\2")
        buf.write(u"\2\u020a\u0207\3\2\2\2\u020a\u0208\3\2\2\2\u020a\u0209")
        buf.write(u"\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020d\7\6\2\2\u020d")
        buf.write(u"\u020f\3\2\2\2\u020e\u020a\3\2\2\2\u020f\u0210\3\2\2")
        buf.write(u"\2\u0210\u020e\3\2\2\2\u0210\u0211\3\2\2\2\u0211_\3\2")
        buf.write(u"\2\2\u0212\u0213\7\20\2\2\u0213\u0214\7\25\2\2\u0214")
        buf.write(u"\u0215\7M\2\2\u0215a\3\2\2\2\u0216\u0217\7\33\2\2\u0217")
        buf.write(u"\u0218\7\25\2\2\u0218\u0219\7M\2\2\u0219c\3\2\2\2\u021a")
        buf.write(u"\u021b\7\26\2\2\u021b\u021c\7\20\2\2\u021c\u021d\7\25")
        buf.write(u"\2\2\u021d\u021e\7M\2\2\u021ee\3\2\2\2\u021f\u0220\7")
        buf.write(u"\26\2\2\u0220\u0221\7\20\2\2\u0221\u0222\7\27\2\2\u0222")
        buf.write(u"g\3\2\2\2\u0223\u0224\7\23\2\2\u0224\u0225\7\24\2\2\u0225")
        buf.write(u"i\3\2\2\2\u0226\u0227\7\34\2\2\u0227\u0228\7\35\2\2\u0228")
        buf.write(u"k\3\2\2\2\u0229\u022a\7\34\2\2\u022a\u022b\7\36\2\2\u022b")
        buf.write(u"m\3\2\2\2\u022c\u023a\5p9\2\u022d\u023a\5r:\2\u022e\u023a")
        buf.write(u"\5t;\2\u022f\u023a\5v<\2\u0230\u023a\5\u009cO\2\u0231")
        buf.write(u"\u023a\5\u009eP\2\u0232\u023a\5\u00a0Q\2\u0233\u023a")
        buf.write(u"\5\u00a2R\2\u0234\u023a\5\u00a4S\2\u0235\u023a\5\u00a6")
        buf.write(u"T\2\u0236\u023a\5\u00aeX\2\u0237\u023a\5\u00a8U\2\u0238")
        buf.write(u"\u023a\5\u00aaV\2\u0239\u022c\3\2\2\2\u0239\u022d\3\2")
        buf.write(u"\2\2\u0239\u022e\3\2\2\2\u0239\u022f\3\2\2\2\u0239\u0230")
        buf.write(u"\3\2\2\2\u0239\u0231\3\2\2\2\u0239\u0232\3\2\2\2\u0239")
        buf.write(u"\u0233\3\2\2\2\u0239\u0234\3\2\2\2\u0239\u0235\3\2\2")
        buf.write(u"\2\u0239\u0236\3\2\2\2\u0239\u0237\3\2\2\2\u0239\u0238")
        buf.write(u"\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023c\7\6\2\2\u023c")
        buf.write(u"\u023e\3\2\2\2\u023d\u0239\3\2\2\2\u023e\u023f\3\2\2")
        buf.write(u"\2\u023f\u023d\3\2\2\2\u023f\u0240\3\2\2\2\u0240o\3\2")
        buf.write(u"\2\2\u0241\u0242\7\34\2\2\u0242\u0243\7\35\2\2\u0243")
        buf.write(u"q\3\2\2\2\u0244\u0245\7\34\2\2\u0245\u0246\7\36\2\2\u0246")
        buf.write(u"s\3\2\2\2\u0247\u0248\7\34\2\2\u0248\u0249\7\37\2\2\u0249")
        buf.write(u"u\3\2\2\2\u024a\u024b\7\34\2\2\u024b\u024c\7 \2\2\u024c")
        buf.write(u"w\3\2\2\2\u024d\u025a\5z>\2\u024e\u025a\5|?\2\u024f\u025a")
        buf.write(u"\5~@\2\u0250\u025a\5\u009cO\2\u0251\u025a\5\u009eP\2")
        buf.write(u"\u0252\u025a\5\u00a0Q\2\u0253\u025a\5\u00a2R\2\u0254")
        buf.write(u"\u025a\5\u00a4S\2\u0255\u025a\5\u00a6T\2\u0256\u025a")
        buf.write(u"\5\u00aeX\2\u0257\u025a\5\u00a8U\2\u0258\u025a\5\u00aa")
        buf.write(u"V\2\u0259\u024d\3\2\2\2\u0259\u024e\3\2\2\2\u0259\u024f")
        buf.write(u"\3\2\2\2\u0259\u0250\3\2\2\2\u0259\u0251\3\2\2\2\u0259")
        buf.write(u"\u0252\3\2\2\2\u0259\u0253\3\2\2\2\u0259\u0254\3\2\2")
        buf.write(u"\2\u0259\u0255\3\2\2\2\u0259\u0256\3\2\2\2\u0259\u0257")
        buf.write(u"\3\2\2\2\u0259\u0258\3\2\2\2\u025a\u025b\3\2\2\2\u025b")
        buf.write(u"\u025c\7\6\2\2\u025c\u025e\3\2\2\2\u025d\u0259\3\2\2")
        buf.write(u"\2\u025e\u025f\3\2\2\2\u025f\u025d\3\2\2\2\u025f\u0260")
        buf.write(u"\3\2\2\2\u0260y\3\2\2\2\u0261\u0262\7\r\2\2\u0262\u0263")
        buf.write(u"\7\30\2\2\u0263\u0264\7J\2\2\u0264{\3\2\2\2\u0265\u0266")
        buf.write(u"\7\23\2\2\u0266\u0267\7\31\2\2\u0267}\3\2\2\2\u0268\u0269")
        buf.write(u"\7\23\2\2\u0269\u026a\7\24\2\2\u026a\177\3\2\2\2\u026b")
        buf.write(u"\u027c\5\u0082B\2\u026c\u027c\5\u0084C\2\u026d\u027c")
        buf.write(u"\5\u0086D\2\u026e\u027c\5\u0088E\2\u026f\u027c\5\u008a")
        buf.write(u"F\2\u0270\u027c\5\u008cG\2\u0271\u027c\5\u008eH\2\u0272")
        buf.write(u"\u027c\5\u009cO\2\u0273\u027c\5\u009eP\2\u0274\u027c")
        buf.write(u"\5\u00a0Q\2\u0275\u027c\5\u00a2R\2\u0276\u027c\5\u00a4")
        buf.write(u"S\2\u0277\u027c\5\u00a6T\2\u0278\u027c\5\u00aeX\2\u0279")
        buf.write(u"\u027c\5\u00a8U\2\u027a\u027c\5\u00aaV\2\u027b\u026b")
        buf.write(u"\3\2\2\2\u027b\u026c\3\2\2\2\u027b\u026d\3\2\2\2\u027b")
        buf.write(u"\u026e\3\2\2\2\u027b\u026f\3\2\2\2\u027b\u0270\3\2\2")
        buf.write(u"\2\u027b\u0271\3\2\2\2\u027b\u0272\3\2\2\2\u027b\u0273")
        buf.write(u"\3\2\2\2\u027b\u0274\3\2\2\2\u027b\u0275\3\2\2\2\u027b")
        buf.write(u"\u0276\3\2\2\2\u027b\u0277\3\2\2\2\u027b\u0278\3\2\2")
        buf.write(u"\2\u027b\u0279\3\2\2\2\u027b\u027a\3\2\2\2\u027c\u027d")
        buf.write(u"\3\2\2\2\u027d\u027e\7\6\2\2\u027e\u0280\3\2\2\2\u027f")
        buf.write(u"\u027b\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u027f\3\2\2")
        buf.write(u"\2\u0281\u0282\3\2\2\2\u0282\u0081\3\2\2\2\u0283\u0284")
        buf.write(u"\7\r\2\2\u0284\u0285\7!\2\2\u0285\u0286\7J\2\2\u0286")
        buf.write(u"\u0083\3\2\2\2\u0287\u0288\7\34\2\2\u0288\u0289\7\35")
        buf.write(u"\2\2\u0289\u0085\3\2\2\2\u028a\u028b\7\34\2\2\u028b\u028c")
        buf.write(u"\7\36\2\2\u028c\u0087\3\2\2\2\u028d\u028e\7\34\2\2\u028e")
        buf.write(u"\u028f\7\37\2\2\u028f\u0089\3\2\2\2\u0290\u0291\7\34")
        buf.write(u"\2\2\u0291\u0292\7 \2\2\u0292\u008b\3\2\2\2\u0293\u0294")
        buf.write(u"\7\20\2\2\u0294\u0295\7\"\2\2\u0295\u008d\3\2\2\2\u0296")
        buf.write(u"\u0297\7\26\2\2\u0297\u0298\7\20\2\2\u0298\u0299\7\"")
        buf.write(u"\2\2\u0299\u008f\3\2\2\2\u029a\u02a9\5\u0092J\2\u029b")
        buf.write(u"\u02a9\5\u0094K\2\u029c\u02a9\5\u0096L\2\u029d\u02a9")
        buf.write(u"\5\u0098M\2\u029e\u02a9\5\u009aN\2\u029f\u02a9\5\u009c")
        buf.write(u"O\2\u02a0\u02a9\5\u009eP\2\u02a1\u02a9\5\u00a0Q\2\u02a2")
        buf.write(u"\u02a9\5\u00a2R\2\u02a3\u02a9\5\u00a4S\2\u02a4\u02a9")
        buf.write(u"\5\u00a6T\2\u02a5\u02a9\5\u00aeX\2\u02a6\u02a9\5\u00a8")
        buf.write(u"U\2\u02a7\u02a9\5\u00aaV\2\u02a8\u029a\3\2\2\2\u02a8")
        buf.write(u"\u029b\3\2\2\2\u02a8\u029c\3\2\2\2\u02a8\u029d\3\2\2")
        buf.write(u"\2\u02a8\u029e\3\2\2\2\u02a8\u029f\3\2\2\2\u02a8\u02a0")
        buf.write(u"\3\2\2\2\u02a8\u02a1\3\2\2\2\u02a8\u02a2\3\2\2\2\u02a8")
        buf.write(u"\u02a3\3\2\2\2\u02a8\u02a4\3\2\2\2\u02a8\u02a5\3\2\2")
        buf.write(u"\2\u02a8\u02a6\3\2\2\2\u02a8\u02a7\3\2\2\2\u02a9\u02aa")
        buf.write(u"\3\2\2\2\u02aa\u02ab\7\6\2\2\u02ab\u02ad\3\2\2\2\u02ac")
        buf.write(u"\u02a8\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02ac\3\2\2")
        buf.write(u"\2\u02ae\u02af\3\2\2\2\u02af\u0091\3\2\2\2\u02b0\u02b1")
        buf.write(u"\7\r\2\2\u02b1\u02b2\7\32\2\2\u02b2\u02b3\7J\2\2\u02b3")
        buf.write(u"\u0093\3\2\2\2\u02b4\u02b5\7\23\2\2\u02b5\u02b6\7\31")
        buf.write(u"\2\2\u02b6\u0095\3\2\2\2\u02b7\u02b8\7\23\2\2\u02b8\u02b9")
        buf.write(u"\7\24\2\2\u02b9\u0097\3\2\2\2\u02ba\u02bb\7\34\2\2\u02bb")
        buf.write(u"\u02bc\7\35\2\2\u02bc\u0099\3\2\2\2\u02bd\u02be\7\34")
        buf.write(u"\2\2\u02be\u02bf\7\36\2\2\u02bf\u009b\3\2\2\2\u02c0\u02c1")
        buf.write(u"\7&\2\2\u02c1\u02c2\7\20\2\2\u02c2\u02c3\5\u00acW\2\u02c3")
        buf.write(u"\u009d\3\2\2\2\u02c4\u02c5\7&\2\2\u02c5\u02c6\7\26\2")
        buf.write(u"\2\u02c6\u02c7\7\20\2\2\u02c7\u02c8\5\u00acW\2\u02c8")
        buf.write(u"\u009f\3\2\2\2\u02c9\u02ca\7&\2\2\u02ca\u02cb\7\'\2\2")
        buf.write(u"\u02cb\u02cc\7(\2\2\u02cc\u02cd\5\u00acW\2\u02cd\u02ce")
        buf.write(u"\7)\2\2\u02ce\u02cf\5\u00acW\2\u02cf\u02d0\7*\2\2\u02d0")
        buf.write(u"\u02d1\7M\2\2\u02d1\u00a1\3\2\2\2\u02d2\u02d3\7&\2\2")
        buf.write(u"\u02d3\u02d4\7+\2\2\u02d4\u02d5\7J\2\2\u02d5\u00a3\3")
        buf.write(u"\2\2\2\u02d6\u02d7\7&\2\2\u02d7\u02d8\7\23\2\2\u02d8")
        buf.write(u"\u02d9\7,\2\2\u02d9\u02da\7\24\2\2\u02da\u00a5\3\2\2")
        buf.write(u"\2\u02db\u02dc\7&\2\2\u02dc\u02dd\7.\2\2\u02dd\u02de")
        buf.write(u"\7M\2\2\u02de\u00a7\3\2\2\2\u02df\u02e0\7&\2\2\u02e0")
        buf.write(u"\u02e1\7\62\2\2\u02e1\u02e2\7\65\2\2\u02e2\u02e3\7\64")
        buf.write(u"\2\2\u02e3\u02e4\7J\2\2\u02e4\u00a9\3\2\2\2\u02e5\u02e6")
        buf.write(u"\7&\2\2\u02e6\u02e7\7\20\2\2\u02e7\u02e8\7\65\2\2\u02e8")
        buf.write(u"\u02e9\7J\2\2\u02e9\u00ab\3\2\2\2\u02ea\u02eb\7M\2\2")
        buf.write(u"\u02eb\u02ec\7M\2\2\u02ec\u00ad\3\2\2\2\u02ed\u02f1\7")
        buf.write(u"-\2\2\u02ee\u02f2\5\u00b0Y\2\u02ef\u02f2\5\u00b2Z\2\u02f0")
        buf.write(u"\u02f2\5\u00b4[\2\u02f1\u02ee\3\2\2\2\u02f1\u02ef\3\2")
        buf.write(u"\2\2\u02f1\u02f0\3\2\2\2\u02f2\u00af\3\2\2\2\u02f3\u02f4")
        buf.write(u"\7/\2\2\u02f4\u00b1\3\2\2\2\u02f5\u02f6\7\60\2\2\u02f6")
        buf.write(u"\u00b3\3\2\2\2\u02f7\u02f8\7\61\2\2\u02f8\u00b5\3\2\2")
        buf.write(u"\2\35\u00c6\u00c8\u00cc\u00d0\u00d4\u00d8\u00dc\u00e0")
        buf.write(u"\u00e4\u00e8\u0195\u019b\u01c6\u01cc\u01e4\u01ea\u020a")
        buf.write(u"\u0210\u0239\u023f\u0259\u025f\u027b\u0281\u02a8\u02ae")
        buf.write(u"\u02f1")
        return buf.getvalue()


class scriptingLanguageParser ( Parser ):

    grammarFileName = "scriptingLanguage.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ u"<INVALID>", u"<INVALID>", u"<INVALID>", u"':'", u"';'" ]

    symbolicNames = [ u"<INVALID>", u"WHEN", u"APP", u"COL", u"SEMICOL", 
                      u"IN", u"CHECK", u"FOR", u"SAME", u"DIFFERENT", u"STATE", 
                      u"INPUT", u"NAME", u"PASSWORD", u"CLICK", u"NEXT", 
                      u"CLOSE", u"PRESS", u"BACK", u"LINE", u"LONG", u"ALL", 
                      u"URL", u"ENTER", u"MESSAGE", u"TOGGLE", u"SWIPE", 
                      u"UP", u"DOWN", u"LEFT", u"RIGHT", u"SEARCH", u"CENTER", 
                      u"TICK", u"ADD", u"TASK", u"CUSTOM", u"DRAG", u"FROM", 
                      u"TO", u"DURATION", u"TYPE", u"DEVICE", u"EXECUTE", 
                      u"SLEEP", u"TESTSLOT1", u"TESTSLOT2", u"TESTSLOT3", 
                      u"ASSERT", u"LINECOUNT", u"EQUALS", u"TEXT", u"CLEAR", 
                      u"FIELDS", u"APPCAT1", u"APPCAT2", u"APPCAT3", u"APPCAT4", 
                      u"APPCAT5", u"APPCAT6", u"APPCAT7", u"APPCAT8", u"APPCAT9", 
                      u"APPCAT10", u"ACTTYPE1", u"ACTTYPE2", u"ACTTYPE3", 
                      u"ACTTYPE4", u"ACTTYPE5", u"ACTTYPE6", u"ACTTYPE7", 
                      u"ACTTYPE8", u"QUOTEDSTRING", u"WHITESPACE", u"NEWLINE", 
                      u"NUMBER" ]

    RULE_suite = 0
    RULE_apptype = 1
    RULE_testlist = 2
    RULE_testtype1 = 3
    RULE_testtype2 = 4
    RULE_testtype3 = 5
    RULE_testtype4 = 6
    RULE_testtype5 = 7
    RULE_testtype6 = 8
    RULE_testtype7 = 9
    RULE_testtype8 = 10
    RULE_testsame1 = 11
    RULE_testdiff1 = 12
    RULE_testsame2 = 13
    RULE_testdiff2 = 14
    RULE_testsame3 = 15
    RULE_testdiff3 = 16
    RULE_testsame4 = 17
    RULE_testdiff4 = 18
    RULE_testsame5 = 19
    RULE_testdiff5 = 20
    RULE_testsame6 = 21
    RULE_testdiff6 = 22
    RULE_testsame7 = 23
    RULE_testdiff7 = 24
    RULE_testsame8 = 25
    RULE_testdiff8 = 26
    RULE_activitytype = 27
    RULE_commandlist1 = 28
    RULE_command1ver1 = 29
    RULE_command1ver2 = 30
    RULE_command1ver3 = 31
    RULE_command1ver4 = 32
    RULE_command1ver5 = 33
    RULE_command1ver6 = 34
    RULE_command1ver7 = 35
    RULE_command1ver8 = 36
    RULE_commandlist2 = 37
    RULE_command2ver1 = 38
    RULE_command2ver2 = 39
    RULE_command2ver3 = 40
    RULE_commandlist3 = 41
    RULE_command3ver1 = 42
    RULE_command3ver2 = 43
    RULE_command3ver3 = 44
    RULE_command3ver4 = 45
    RULE_commandlist4 = 46
    RULE_command4ver1 = 47
    RULE_command4ver2 = 48
    RULE_command4ver3 = 49
    RULE_command4ver4 = 50
    RULE_command4ver5 = 51
    RULE_command4ver6 = 52
    RULE_command4ver7 = 53
    RULE_commandlist5 = 54
    RULE_command5ver1 = 55
    RULE_command5ver2 = 56
    RULE_command5ver3 = 57
    RULE_command5ver4 = 58
    RULE_commandlist6 = 59
    RULE_command6ver1 = 60
    RULE_command6ver2 = 61
    RULE_command6ver3 = 62
    RULE_commandlist7 = 63
    RULE_command7ver1 = 64
    RULE_command7ver2 = 65
    RULE_command7ver3 = 66
    RULE_command7ver4 = 67
    RULE_command7ver5 = 68
    RULE_command7ver6 = 69
    RULE_command7ver7 = 70
    RULE_commandlist8 = 71
    RULE_command8ver1 = 72
    RULE_command8ver2 = 73
    RULE_command8ver3 = 74
    RULE_command8ver4 = 75
    RULE_command8ver5 = 76
    RULE_commandCustomClick = 77
    RULE_commandCustomLongClick = 78
    RULE_commandCustomDrag = 79
    RULE_commandCustomType = 80
    RULE_commandCustomBack = 81
    RULE_commandCustomSleep = 82
    RULE_commandCustomAssertText = 83
    RULE_commandCustomClickText = 84
    RULE_coordinate = 85
    RULE_testCustom = 86
    RULE_testSlot1 = 87
    RULE_testSlot2 = 88
    RULE_testSlot3 = 89

    ruleNames =  [ u"suite", u"apptype", u"testlist", u"testtype1", u"testtype2", 
                   u"testtype3", u"testtype4", u"testtype5", u"testtype6", 
                   u"testtype7", u"testtype8", u"testsame1", u"testdiff1", 
                   u"testsame2", u"testdiff2", u"testsame3", u"testdiff3", 
                   u"testsame4", u"testdiff4", u"testsame5", u"testdiff5", 
                   u"testsame6", u"testdiff6", u"testsame7", u"testdiff7", 
                   u"testsame8", u"testdiff8", u"activitytype", u"commandlist1", 
                   u"command1ver1", u"command1ver2", u"command1ver3", u"command1ver4", 
                   u"command1ver5", u"command1ver6", u"command1ver7", u"command1ver8", 
                   u"commandlist2", u"command2ver1", u"command2ver2", u"command2ver3", 
                   u"commandlist3", u"command3ver1", u"command3ver2", u"command3ver3", 
                   u"command3ver4", u"commandlist4", u"command4ver1", u"command4ver2", 
                   u"command4ver3", u"command4ver4", u"command4ver5", u"command4ver6", 
                   u"command4ver7", u"commandlist5", u"command5ver1", u"command5ver2", 
                   u"command5ver3", u"command5ver4", u"commandlist6", u"command6ver1", 
                   u"command6ver2", u"command6ver3", u"commandlist7", u"command7ver1", 
                   u"command7ver2", u"command7ver3", u"command7ver4", u"command7ver5", 
                   u"command7ver6", u"command7ver7", u"commandlist8", u"command8ver1", 
                   u"command8ver2", u"command8ver3", u"command8ver4", u"command8ver5", 
                   u"commandCustomClick", u"commandCustomLongClick", u"commandCustomDrag", 
                   u"commandCustomType", u"commandCustomBack", u"commandCustomSleep", 
                   u"commandCustomAssertText", u"commandCustomClickText", 
                   u"coordinate", u"testCustom", u"testSlot1", u"testSlot2", 
                   u"testSlot3" ]

    EOF = Token.EOF
    WHEN=1
    APP=2
    COL=3
    SEMICOL=4
    IN=5
    CHECK=6
    FOR=7
    SAME=8
    DIFFERENT=9
    STATE=10
    INPUT=11
    NAME=12
    PASSWORD=13
    CLICK=14
    NEXT=15
    CLOSE=16
    PRESS=17
    BACK=18
    LINE=19
    LONG=20
    ALL=21
    URL=22
    ENTER=23
    MESSAGE=24
    TOGGLE=25
    SWIPE=26
    UP=27
    DOWN=28
    LEFT=29
    RIGHT=30
    SEARCH=31
    CENTER=32
    TICK=33
    ADD=34
    TASK=35
    CUSTOM=36
    DRAG=37
    FROM=38
    TO=39
    DURATION=40
    TYPE=41
    DEVICE=42
    EXECUTE=43
    SLEEP=44
    TESTSLOT1=45
    TESTSLOT2=46
    TESTSLOT3=47
    ASSERT=48
    LINECOUNT=49
    EQUALS=50
    TEXT=51
    CLEAR=52
    FIELDS=53
    APPCAT1=54
    APPCAT2=55
    APPCAT3=56
    APPCAT4=57
    APPCAT5=58
    APPCAT6=59
    APPCAT7=60
    APPCAT8=61
    APPCAT9=62
    APPCAT10=63
    ACTTYPE1=64
    ACTTYPE2=65
    ACTTYPE3=66
    ACTTYPE4=67
    ACTTYPE5=68
    ACTTYPE6=69
    ACTTYPE7=70
    ACTTYPE8=71
    QUOTEDSTRING=72
    WHITESPACE=73
    NEWLINE=74
    NUMBER=75

    def __init__(self, input, output=sys.stdout):
        super(scriptingLanguageParser, self).__init__(input, output=output)
        self.checkVersion("4.7.1")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None



    class SuiteContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.SuiteContext, self).__init__(parent, invokingState)
            self.parser = parser

        def WHEN(self):
            return self.getToken(scriptingLanguageParser.WHEN, 0)

        def apptype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ApptypeContext,0)


        def APP(self):
            return self.getToken(scriptingLanguageParser.APP, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def testlist(self):
            return self.getTypedRuleContext(scriptingLanguageParser.TestlistContext,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_suite

        def enterRule(self, listener):
            if hasattr(listener, "enterSuite"):
                listener.enterSuite(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitSuite"):
                listener.exitSuite(self)




    def suite(self):

        localctx = scriptingLanguageParser.SuiteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_suite)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 180
            self.match(scriptingLanguageParser.WHEN)
            self.state = 181
            self.apptype()
            self.state = 182
            self.match(scriptingLanguageParser.APP)
            self.state = 183
            self.match(scriptingLanguageParser.COL)
            self.state = 184
            self.testlist()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ApptypeContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.ApptypeContext, self).__init__(parent, invokingState)
            self.parser = parser

        def APPCAT1(self):
            return self.getToken(scriptingLanguageParser.APPCAT1, 0)

        def APPCAT2(self):
            return self.getToken(scriptingLanguageParser.APPCAT2, 0)

        def APPCAT3(self):
            return self.getToken(scriptingLanguageParser.APPCAT3, 0)

        def APPCAT4(self):
            return self.getToken(scriptingLanguageParser.APPCAT4, 0)

        def APPCAT5(self):
            return self.getToken(scriptingLanguageParser.APPCAT5, 0)

        def APPCAT6(self):
            return self.getToken(scriptingLanguageParser.APPCAT6, 0)

        def APPCAT7(self):
            return self.getToken(scriptingLanguageParser.APPCAT7, 0)

        def APPCAT8(self):
            return self.getToken(scriptingLanguageParser.APPCAT8, 0)

        def APPCAT9(self):
            return self.getToken(scriptingLanguageParser.APPCAT9, 0)

        def APPCAT10(self):
            return self.getToken(scriptingLanguageParser.APPCAT10, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_apptype

        def enterRule(self, listener):
            if hasattr(listener, "enterApptype"):
                listener.enterApptype(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitApptype"):
                listener.exitApptype(self)




    def apptype(self):

        localctx = scriptingLanguageParser.ApptypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_apptype)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 186
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.APPCAT1) | (1 << scriptingLanguageParser.APPCAT2) | (1 << scriptingLanguageParser.APPCAT3) | (1 << scriptingLanguageParser.APPCAT4) | (1 << scriptingLanguageParser.APPCAT5) | (1 << scriptingLanguageParser.APPCAT6) | (1 << scriptingLanguageParser.APPCAT7) | (1 << scriptingLanguageParser.APPCAT8) | (1 << scriptingLanguageParser.APPCAT9) | (1 << scriptingLanguageParser.APPCAT10))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TestlistContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.TestlistContext, self).__init__(parent, invokingState)
            self.parser = parser

        def testtype1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype1Context,i)


        def testtype2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype2Context,i)


        def testtype3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype3Context,i)


        def testtype4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype4Context,i)


        def testtype5(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype5Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype5Context,i)


        def testtype6(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype6Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype6Context,i)


        def testtype7(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype7Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype7Context,i)


        def testtype8(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Testtype8Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Testtype8Context,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testlist

        def enterRule(self, listener):
            if hasattr(listener, "enterTestlist"):
                listener.enterTestlist(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestlist"):
                listener.exitTestlist(self)




    def testlist(self):

        localctx = scriptingLanguageParser.TestlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_testlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 196 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 196
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 188
                    self.testtype1()
                    pass

                elif la_ == 2:
                    self.state = 189
                    self.testtype2()
                    pass

                elif la_ == 3:
                    self.state = 190
                    self.testtype3()
                    pass

                elif la_ == 4:
                    self.state = 191
                    self.testtype4()
                    pass

                elif la_ == 5:
                    self.state = 192
                    self.testtype5()
                    pass

                elif la_ == 6:
                    self.state = 193
                    self.testtype6()
                    pass

                elif la_ == 7:
                    self.state = 194
                    self.testtype7()
                    pass

                elif la_ == 8:
                    self.state = 195
                    self.testtype8()
                    pass


                self.state = 198 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==scriptingLanguageParser.IN):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame1(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame1Context,0)


        def testdiff1(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff1Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype1

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype1"):
                listener.enterTesttype1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype1"):
                listener.exitTesttype1(self)




    def testtype1(self):

        localctx = scriptingLanguageParser.Testtype1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_testtype1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 202
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 200
                self.testsame1()
                pass

            elif la_ == 2:
                self.state = 201
                self.testdiff1()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame2(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame2Context,0)


        def testdiff2(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff2Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype2

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype2"):
                listener.enterTesttype2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype2"):
                listener.exitTesttype2(self)




    def testtype2(self):

        localctx = scriptingLanguageParser.Testtype2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_testtype2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 206
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.state = 204
                self.testsame2()
                pass

            elif la_ == 2:
                self.state = 205
                self.testdiff2()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame3(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame3Context,0)


        def testdiff3(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff3Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype3

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype3"):
                listener.enterTesttype3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype3"):
                listener.exitTesttype3(self)




    def testtype3(self):

        localctx = scriptingLanguageParser.Testtype3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_testtype3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 210
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.state = 208
                self.testsame3()
                pass

            elif la_ == 2:
                self.state = 209
                self.testdiff3()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame4(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame4Context,0)


        def testdiff4(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff4Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype4

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype4"):
                listener.enterTesttype4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype4"):
                listener.exitTesttype4(self)




    def testtype4(self):

        localctx = scriptingLanguageParser.Testtype4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_testtype4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 214
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.state = 212
                self.testsame4()
                pass

            elif la_ == 2:
                self.state = 213
                self.testdiff4()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame5(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame5Context,0)


        def testdiff5(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff5Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype5

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype5"):
                listener.enterTesttype5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype5"):
                listener.exitTesttype5(self)




    def testtype5(self):

        localctx = scriptingLanguageParser.Testtype5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_testtype5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 218
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.state = 216
                self.testsame5()
                pass

            elif la_ == 2:
                self.state = 217
                self.testdiff5()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame6(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame6Context,0)


        def testdiff6(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff6Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype6

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype6"):
                listener.enterTesttype6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype6"):
                listener.exitTesttype6(self)




    def testtype6(self):

        localctx = scriptingLanguageParser.Testtype6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_testtype6)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 222
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 220
                self.testsame6()
                pass

            elif la_ == 2:
                self.state = 221
                self.testdiff6()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame7(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame7Context,0)


        def testdiff7(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff7Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype7

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype7"):
                listener.enterTesttype7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype7"):
                listener.exitTesttype7(self)




    def testtype7(self):

        localctx = scriptingLanguageParser.Testtype7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_testtype7)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 226
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 224
                self.testsame7()
                pass

            elif la_ == 2:
                self.state = 225
                self.testdiff7()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testtype8Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testtype8Context, self).__init__(parent, invokingState)
            self.parser = parser

        def testsame8(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testsame8Context,0)


        def testdiff8(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Testdiff8Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testtype8

        def enterRule(self, listener):
            if hasattr(listener, "enterTesttype8"):
                listener.enterTesttype8(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTesttype8"):
                listener.exitTesttype8(self)




    def testtype8(self):

        localctx = scriptingLanguageParser.Testtype8Context(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_testtype8)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 230
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 228
                self.testsame8()
                pass

            elif la_ == 2:
                self.state = 229
                self.testdiff8()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE1(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE1, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist1(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist1Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame1

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame1"):
                listener.enterTestsame1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame1"):
                listener.exitTestsame1(self)




    def testsame1(self):

        localctx = scriptingLanguageParser.Testsame1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_testsame1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(scriptingLanguageParser.IN)
            self.state = 233
            self.match(scriptingLanguageParser.ACTTYPE1)
            self.state = 234
            self.match(scriptingLanguageParser.CHECK)
            self.state = 235
            self.match(scriptingLanguageParser.FOR)
            self.state = 236
            self.match(scriptingLanguageParser.SAME)
            self.state = 237
            self.match(scriptingLanguageParser.STATE)
            self.state = 238
            self.match(scriptingLanguageParser.COL)
            self.state = 239
            self.commandlist1()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE1(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE1, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist1(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist1Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff1

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff1"):
                listener.enterTestdiff1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff1"):
                listener.exitTestdiff1(self)




    def testdiff1(self):

        localctx = scriptingLanguageParser.Testdiff1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_testdiff1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 241
            self.match(scriptingLanguageParser.IN)
            self.state = 242
            self.match(scriptingLanguageParser.ACTTYPE1)
            self.state = 243
            self.match(scriptingLanguageParser.CHECK)
            self.state = 244
            self.match(scriptingLanguageParser.FOR)
            self.state = 245
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 246
            self.match(scriptingLanguageParser.STATE)
            self.state = 247
            self.activitytype()
            self.state = 248
            self.match(scriptingLanguageParser.COL)
            self.state = 249
            self.commandlist1()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE2(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE2, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist2(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist2Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame2

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame2"):
                listener.enterTestsame2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame2"):
                listener.exitTestsame2(self)




    def testsame2(self):

        localctx = scriptingLanguageParser.Testsame2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_testsame2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 251
            self.match(scriptingLanguageParser.IN)
            self.state = 252
            self.match(scriptingLanguageParser.ACTTYPE2)
            self.state = 253
            self.match(scriptingLanguageParser.CHECK)
            self.state = 254
            self.match(scriptingLanguageParser.FOR)
            self.state = 255
            self.match(scriptingLanguageParser.SAME)
            self.state = 256
            self.match(scriptingLanguageParser.STATE)
            self.state = 257
            self.match(scriptingLanguageParser.COL)
            self.state = 258
            self.commandlist2()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE2(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE2, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist2(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist2Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff2

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff2"):
                listener.enterTestdiff2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff2"):
                listener.exitTestdiff2(self)




    def testdiff2(self):

        localctx = scriptingLanguageParser.Testdiff2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_testdiff2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 260
            self.match(scriptingLanguageParser.IN)
            self.state = 261
            self.match(scriptingLanguageParser.ACTTYPE2)
            self.state = 262
            self.match(scriptingLanguageParser.CHECK)
            self.state = 263
            self.match(scriptingLanguageParser.FOR)
            self.state = 264
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 265
            self.match(scriptingLanguageParser.STATE)
            self.state = 266
            self.activitytype()
            self.state = 267
            self.match(scriptingLanguageParser.COL)
            self.state = 268
            self.commandlist2()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE3(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE3, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist3(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist3Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame3

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame3"):
                listener.enterTestsame3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame3"):
                listener.exitTestsame3(self)




    def testsame3(self):

        localctx = scriptingLanguageParser.Testsame3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_testsame3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.match(scriptingLanguageParser.IN)
            self.state = 271
            self.match(scriptingLanguageParser.ACTTYPE3)
            self.state = 272
            self.match(scriptingLanguageParser.CHECK)
            self.state = 273
            self.match(scriptingLanguageParser.FOR)
            self.state = 274
            self.match(scriptingLanguageParser.SAME)
            self.state = 275
            self.match(scriptingLanguageParser.STATE)
            self.state = 276
            self.match(scriptingLanguageParser.COL)
            self.state = 277
            self.commandlist3()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE3(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE3, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist3(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist3Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff3

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff3"):
                listener.enterTestdiff3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff3"):
                listener.exitTestdiff3(self)




    def testdiff3(self):

        localctx = scriptingLanguageParser.Testdiff3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_testdiff3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 279
            self.match(scriptingLanguageParser.IN)
            self.state = 280
            self.match(scriptingLanguageParser.ACTTYPE3)
            self.state = 281
            self.match(scriptingLanguageParser.CHECK)
            self.state = 282
            self.match(scriptingLanguageParser.FOR)
            self.state = 283
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 284
            self.match(scriptingLanguageParser.STATE)
            self.state = 285
            self.activitytype()
            self.state = 286
            self.match(scriptingLanguageParser.COL)
            self.state = 287
            self.commandlist3()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE4(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE4, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist4(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist4Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame4

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame4"):
                listener.enterTestsame4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame4"):
                listener.exitTestsame4(self)




    def testsame4(self):

        localctx = scriptingLanguageParser.Testsame4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_testsame4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 289
            self.match(scriptingLanguageParser.IN)
            self.state = 290
            self.match(scriptingLanguageParser.ACTTYPE4)
            self.state = 291
            self.match(scriptingLanguageParser.CHECK)
            self.state = 292
            self.match(scriptingLanguageParser.FOR)
            self.state = 293
            self.match(scriptingLanguageParser.SAME)
            self.state = 294
            self.match(scriptingLanguageParser.STATE)
            self.state = 295
            self.match(scriptingLanguageParser.COL)
            self.state = 296
            self.commandlist4()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE4(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE4, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist4(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist4Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff4

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff4"):
                listener.enterTestdiff4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff4"):
                listener.exitTestdiff4(self)




    def testdiff4(self):

        localctx = scriptingLanguageParser.Testdiff4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_testdiff4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.match(scriptingLanguageParser.IN)
            self.state = 299
            self.match(scriptingLanguageParser.ACTTYPE4)
            self.state = 300
            self.match(scriptingLanguageParser.CHECK)
            self.state = 301
            self.match(scriptingLanguageParser.FOR)
            self.state = 302
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 303
            self.match(scriptingLanguageParser.STATE)
            self.state = 304
            self.activitytype()
            self.state = 305
            self.match(scriptingLanguageParser.COL)
            self.state = 306
            self.commandlist4()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE5(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE5, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist5(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist5Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame5

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame5"):
                listener.enterTestsame5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame5"):
                listener.exitTestsame5(self)




    def testsame5(self):

        localctx = scriptingLanguageParser.Testsame5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_testsame5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.match(scriptingLanguageParser.IN)
            self.state = 309
            self.match(scriptingLanguageParser.ACTTYPE5)
            self.state = 310
            self.match(scriptingLanguageParser.CHECK)
            self.state = 311
            self.match(scriptingLanguageParser.FOR)
            self.state = 312
            self.match(scriptingLanguageParser.SAME)
            self.state = 313
            self.match(scriptingLanguageParser.STATE)
            self.state = 314
            self.match(scriptingLanguageParser.COL)
            self.state = 315
            self.commandlist5()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE5(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE5, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist5(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist5Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff5

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff5"):
                listener.enterTestdiff5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff5"):
                listener.exitTestdiff5(self)




    def testdiff5(self):

        localctx = scriptingLanguageParser.Testdiff5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_testdiff5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.match(scriptingLanguageParser.IN)
            self.state = 318
            self.match(scriptingLanguageParser.ACTTYPE5)
            self.state = 319
            self.match(scriptingLanguageParser.CHECK)
            self.state = 320
            self.match(scriptingLanguageParser.FOR)
            self.state = 321
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 322
            self.match(scriptingLanguageParser.STATE)
            self.state = 323
            self.activitytype()
            self.state = 324
            self.match(scriptingLanguageParser.COL)
            self.state = 325
            self.commandlist5()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE6(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE6, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist6(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist6Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame6

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame6"):
                listener.enterTestsame6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame6"):
                listener.exitTestsame6(self)




    def testsame6(self):

        localctx = scriptingLanguageParser.Testsame6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_testsame6)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(scriptingLanguageParser.IN)
            self.state = 328
            self.match(scriptingLanguageParser.ACTTYPE6)
            self.state = 329
            self.match(scriptingLanguageParser.CHECK)
            self.state = 330
            self.match(scriptingLanguageParser.FOR)
            self.state = 331
            self.match(scriptingLanguageParser.SAME)
            self.state = 332
            self.match(scriptingLanguageParser.STATE)
            self.state = 333
            self.match(scriptingLanguageParser.COL)
            self.state = 334
            self.commandlist6()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE6(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE6, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist6(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist6Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff6

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff6"):
                listener.enterTestdiff6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff6"):
                listener.exitTestdiff6(self)




    def testdiff6(self):

        localctx = scriptingLanguageParser.Testdiff6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_testdiff6)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self.match(scriptingLanguageParser.IN)
            self.state = 337
            self.match(scriptingLanguageParser.ACTTYPE6)
            self.state = 338
            self.match(scriptingLanguageParser.CHECK)
            self.state = 339
            self.match(scriptingLanguageParser.FOR)
            self.state = 340
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 341
            self.match(scriptingLanguageParser.STATE)
            self.state = 342
            self.activitytype()
            self.state = 343
            self.match(scriptingLanguageParser.COL)
            self.state = 344
            self.commandlist6()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE7(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE7, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist7(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist7Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame7

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame7"):
                listener.enterTestsame7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame7"):
                listener.exitTestsame7(self)




    def testsame7(self):

        localctx = scriptingLanguageParser.Testsame7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_testsame7)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 346
            self.match(scriptingLanguageParser.IN)
            self.state = 347
            self.match(scriptingLanguageParser.ACTTYPE7)
            self.state = 348
            self.match(scriptingLanguageParser.CHECK)
            self.state = 349
            self.match(scriptingLanguageParser.FOR)
            self.state = 350
            self.match(scriptingLanguageParser.SAME)
            self.state = 351
            self.match(scriptingLanguageParser.STATE)
            self.state = 352
            self.match(scriptingLanguageParser.COL)
            self.state = 353
            self.commandlist7()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE7(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE7, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist7(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist7Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff7

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff7"):
                listener.enterTestdiff7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff7"):
                listener.exitTestdiff7(self)




    def testdiff7(self):

        localctx = scriptingLanguageParser.Testdiff7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_testdiff7)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 355
            self.match(scriptingLanguageParser.IN)
            self.state = 356
            self.match(scriptingLanguageParser.ACTTYPE7)
            self.state = 357
            self.match(scriptingLanguageParser.CHECK)
            self.state = 358
            self.match(scriptingLanguageParser.FOR)
            self.state = 359
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 360
            self.match(scriptingLanguageParser.STATE)
            self.state = 361
            self.activitytype()
            self.state = 362
            self.match(scriptingLanguageParser.COL)
            self.state = 363
            self.commandlist7()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testsame8Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testsame8Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE8(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE8, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def SAME(self):
            return self.getToken(scriptingLanguageParser.SAME, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist8(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist8Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testsame8

        def enterRule(self, listener):
            if hasattr(listener, "enterTestsame8"):
                listener.enterTestsame8(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestsame8"):
                listener.exitTestsame8(self)




    def testsame8(self):

        localctx = scriptingLanguageParser.Testsame8Context(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_testsame8)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 365
            self.match(scriptingLanguageParser.IN)
            self.state = 366
            self.match(scriptingLanguageParser.ACTTYPE8)
            self.state = 367
            self.match(scriptingLanguageParser.CHECK)
            self.state = 368
            self.match(scriptingLanguageParser.FOR)
            self.state = 369
            self.match(scriptingLanguageParser.SAME)
            self.state = 370
            self.match(scriptingLanguageParser.STATE)
            self.state = 371
            self.match(scriptingLanguageParser.COL)
            self.state = 372
            self.commandlist8()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Testdiff8Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Testdiff8Context, self).__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(scriptingLanguageParser.IN, 0)

        def ACTTYPE8(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE8, 0)

        def CHECK(self):
            return self.getToken(scriptingLanguageParser.CHECK, 0)

        def FOR(self):
            return self.getToken(scriptingLanguageParser.FOR, 0)

        def DIFFERENT(self):
            return self.getToken(scriptingLanguageParser.DIFFERENT, 0)

        def STATE(self):
            return self.getToken(scriptingLanguageParser.STATE, 0)

        def activitytype(self):
            return self.getTypedRuleContext(scriptingLanguageParser.ActivitytypeContext,0)


        def COL(self):
            return self.getToken(scriptingLanguageParser.COL, 0)

        def commandlist8(self):
            return self.getTypedRuleContext(scriptingLanguageParser.Commandlist8Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testdiff8

        def enterRule(self, listener):
            if hasattr(listener, "enterTestdiff8"):
                listener.enterTestdiff8(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestdiff8"):
                listener.exitTestdiff8(self)




    def testdiff8(self):

        localctx = scriptingLanguageParser.Testdiff8Context(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_testdiff8)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 374
            self.match(scriptingLanguageParser.IN)
            self.state = 375
            self.match(scriptingLanguageParser.ACTTYPE8)
            self.state = 376
            self.match(scriptingLanguageParser.CHECK)
            self.state = 377
            self.match(scriptingLanguageParser.FOR)
            self.state = 378
            self.match(scriptingLanguageParser.DIFFERENT)
            self.state = 379
            self.match(scriptingLanguageParser.STATE)
            self.state = 380
            self.activitytype()
            self.state = 381
            self.match(scriptingLanguageParser.COL)
            self.state = 382
            self.commandlist8()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActivitytypeContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.ActivitytypeContext, self).__init__(parent, invokingState)
            self.parser = parser

        def ACTTYPE1(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE1, 0)

        def ACTTYPE2(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE2, 0)

        def ACTTYPE3(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE3, 0)

        def ACTTYPE4(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE4, 0)

        def ACTTYPE5(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE5, 0)

        def ACTTYPE6(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE6, 0)

        def ACTTYPE7(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE7, 0)

        def ACTTYPE8(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE8, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_activitytype

        def enterRule(self, listener):
            if hasattr(listener, "enterActivitytype"):
                listener.enterActivitytype(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitActivitytype"):
                listener.exitActivitytype(self)




    def activitytype(self):

        localctx = scriptingLanguageParser.ActivitytypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_activitytype)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 384
            _la = self._input.LA(1)
            if not(((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (scriptingLanguageParser.ACTTYPE1 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE2 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE3 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE4 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE5 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE6 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE7 - 64)) | (1 << (scriptingLanguageParser.ACTTYPE8 - 64)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command1ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver1Context,i)


        def command1ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver2Context,i)


        def command1ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver3Context,i)


        def command1ver4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver4Context,i)


        def command1ver5(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver5Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver5Context,i)


        def command1ver6(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver6Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver6Context,i)


        def command1ver7(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver7Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver7Context,i)


        def command1ver8(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command1ver8Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command1ver8Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist1"):
                listener.enterCommandlist1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist1"):
                listener.exitCommandlist1(self)




    def commandlist1(self):

        localctx = scriptingLanguageParser.Commandlist1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_commandlist1)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 407 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 403
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
                if la_ == 1:
                    self.state = 386
                    self.command1ver1()
                    pass

                elif la_ == 2:
                    self.state = 387
                    self.command1ver2()
                    pass

                elif la_ == 3:
                    self.state = 388
                    self.command1ver3()
                    pass

                elif la_ == 4:
                    self.state = 389
                    self.command1ver4()
                    pass

                elif la_ == 5:
                    self.state = 390
                    self.command1ver5()
                    pass

                elif la_ == 6:
                    self.state = 391
                    self.command1ver6()
                    pass

                elif la_ == 7:
                    self.state = 392
                    self.command1ver7()
                    pass

                elif la_ == 8:
                    self.state = 393
                    self.command1ver8()
                    pass

                elif la_ == 9:
                    self.state = 394
                    self.commandCustomClick()
                    pass

                elif la_ == 10:
                    self.state = 395
                    self.commandCustomLongClick()
                    pass

                elif la_ == 11:
                    self.state = 396
                    self.commandCustomDrag()
                    pass

                elif la_ == 12:
                    self.state = 397
                    self.commandCustomType()
                    pass

                elif la_ == 13:
                    self.state = 398
                    self.commandCustomBack()
                    pass

                elif la_ == 14:
                    self.state = 399
                    self.commandCustomSleep()
                    pass

                elif la_ == 15:
                    self.state = 400
                    self.testCustom()
                    pass

                elif la_ == 16:
                    self.state = 401
                    self.commandCustomAssertText()
                    pass

                elif la_ == 17:
                    self.state = 402
                    self.commandCustomClickText()
                    pass


                self.state = 405
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 409 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.CLICK) | (1 << scriptingLanguageParser.PRESS) | (1 << scriptingLanguageParser.SWIPE) | (1 << scriptingLanguageParser.TICK) | (1 << scriptingLanguageParser.ADD) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE) | (1 << scriptingLanguageParser.ASSERT))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def ADD(self):
            return self.getToken(scriptingLanguageParser.ADD, 0)

        def TASK(self):
            return self.getToken(scriptingLanguageParser.TASK, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver1"):
                listener.enterCommand1ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver1"):
                listener.exitCommand1ver1(self)




    def command1ver1(self):

        localctx = scriptingLanguageParser.Command1ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_command1ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 411
            self.match(scriptingLanguageParser.ADD)
            self.state = 412
            self.match(scriptingLanguageParser.TASK)
            self.state = 413
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def TICK(self):
            return self.getToken(scriptingLanguageParser.TICK, 0)

        def LINE(self):
            return self.getToken(scriptingLanguageParser.LINE, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver2"):
                listener.enterCommand1ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver2"):
                listener.exitCommand1ver2(self)




    def command1ver2(self):

        localctx = scriptingLanguageParser.Command1ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_command1ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            self.match(scriptingLanguageParser.TICK)
            self.state = 416
            self.match(scriptingLanguageParser.LINE)
            self.state = 417
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def TICK(self):
            return self.getToken(scriptingLanguageParser.TICK, 0)

        def ALL(self):
            return self.getToken(scriptingLanguageParser.ALL, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver3"):
                listener.enterCommand1ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver3"):
                listener.exitCommand1ver3(self)




    def command1ver3(self):

        localctx = scriptingLanguageParser.Command1ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_command1ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self.match(scriptingLanguageParser.TICK)
            self.state = 420
            self.match(scriptingLanguageParser.ALL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def LINE(self):
            return self.getToken(scriptingLanguageParser.LINE, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver4"):
                listener.enterCommand1ver4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver4"):
                listener.exitCommand1ver4(self)




    def command1ver4(self):

        localctx = scriptingLanguageParser.Command1ver4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_command1ver4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 422
            self.match(scriptingLanguageParser.CLICK)
            self.state = 423
            self.match(scriptingLanguageParser.LINE)
            self.state = 424
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def BACK(self):
            return self.getToken(scriptingLanguageParser.BACK, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver5

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver5"):
                listener.enterCommand1ver5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver5"):
                listener.exitCommand1ver5(self)




    def command1ver5(self):

        localctx = scriptingLanguageParser.Command1ver5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_command1ver5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 426
            self.match(scriptingLanguageParser.PRESS)
            self.state = 427
            self.match(scriptingLanguageParser.BACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def UP(self):
            return self.getToken(scriptingLanguageParser.UP, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver6

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver6"):
                listener.enterCommand1ver6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver6"):
                listener.exitCommand1ver6(self)




    def command1ver6(self):

        localctx = scriptingLanguageParser.Command1ver6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_command1ver6)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 430
            self.match(scriptingLanguageParser.UP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def DOWN(self):
            return self.getToken(scriptingLanguageParser.DOWN, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver7

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver7"):
                listener.enterCommand1ver7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver7"):
                listener.exitCommand1ver7(self)




    def command1ver7(self):

        localctx = scriptingLanguageParser.Command1ver7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_command1ver7)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 432
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 433
            self.match(scriptingLanguageParser.DOWN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command1ver8Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command1ver8Context, self).__init__(parent, invokingState)
            self.parser = parser

        def ASSERT(self):
            return self.getToken(scriptingLanguageParser.ASSERT, 0)

        def LINECOUNT(self):
            return self.getToken(scriptingLanguageParser.LINECOUNT, 0)

        def EQUALS(self):
            return self.getToken(scriptingLanguageParser.EQUALS, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command1ver8

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand1ver8"):
                listener.enterCommand1ver8(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand1ver8"):
                listener.exitCommand1ver8(self)




    def command1ver8(self):

        localctx = scriptingLanguageParser.Command1ver8Context(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_command1ver8)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 435
            self.match(scriptingLanguageParser.ASSERT)
            self.state = 436
            self.match(scriptingLanguageParser.LINECOUNT)
            self.state = 437
            self.match(scriptingLanguageParser.EQUALS)
            self.state = 438
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command2ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command2ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command2ver1Context,i)


        def command2ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command2ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command2ver2Context,i)


        def command2ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command2ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command2ver3Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist2"):
                listener.enterCommandlist2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist2"):
                listener.exitCommandlist2(self)




    def commandlist2(self):

        localctx = scriptingLanguageParser.Commandlist2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_commandlist2)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 456 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 452
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                if la_ == 1:
                    self.state = 440
                    self.command2ver1()
                    pass

                elif la_ == 2:
                    self.state = 441
                    self.command2ver2()
                    pass

                elif la_ == 3:
                    self.state = 442
                    self.command2ver3()
                    pass

                elif la_ == 4:
                    self.state = 443
                    self.commandCustomClick()
                    pass

                elif la_ == 5:
                    self.state = 444
                    self.commandCustomLongClick()
                    pass

                elif la_ == 6:
                    self.state = 445
                    self.commandCustomDrag()
                    pass

                elif la_ == 7:
                    self.state = 446
                    self.commandCustomType()
                    pass

                elif la_ == 8:
                    self.state = 447
                    self.commandCustomBack()
                    pass

                elif la_ == 9:
                    self.state = 448
                    self.commandCustomSleep()
                    pass

                elif la_ == 10:
                    self.state = 449
                    self.testCustom()
                    pass

                elif la_ == 11:
                    self.state = 450
                    self.commandCustomAssertText()
                    pass

                elif la_ == 12:
                    self.state = 451
                    self.commandCustomClickText()
                    pass


                self.state = 454
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 458 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.CLICK) | (1 << scriptingLanguageParser.PRESS) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command2ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command2ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def CLOSE(self):
            return self.getToken(scriptingLanguageParser.CLOSE, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command2ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand2ver1"):
                listener.enterCommand2ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand2ver1"):
                listener.exitCommand2ver1(self)




    def command2ver1(self):

        localctx = scriptingLanguageParser.Command2ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_command2ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 460
            self.match(scriptingLanguageParser.CLICK)
            self.state = 461
            self.match(scriptingLanguageParser.CLOSE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command2ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command2ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def ACTTYPE2(self):
            return self.getToken(scriptingLanguageParser.ACTTYPE2, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command2ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand2ver2"):
                listener.enterCommand2ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand2ver2"):
                listener.exitCommand2ver2(self)




    def command2ver2(self):

        localctx = scriptingLanguageParser.Command2ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_command2ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.match(scriptingLanguageParser.CLICK)
            self.state = 464
            self.match(scriptingLanguageParser.ACTTYPE2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command2ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command2ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def BACK(self):
            return self.getToken(scriptingLanguageParser.BACK, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command2ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand2ver3"):
                listener.enterCommand2ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand2ver3"):
                listener.exitCommand2ver3(self)




    def command2ver3(self):

        localctx = scriptingLanguageParser.Command2ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_command2ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 466
            self.match(scriptingLanguageParser.PRESS)
            self.state = 467
            self.match(scriptingLanguageParser.BACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command3ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command3ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command3ver1Context,i)


        def command3ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command3ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command3ver2Context,i)


        def command3ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command3ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command3ver3Context,i)


        def command3ver4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command3ver4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command3ver4Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist3"):
                listener.enterCommandlist3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist3"):
                listener.exitCommandlist3(self)




    def commandlist3(self):

        localctx = scriptingLanguageParser.Commandlist3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_commandlist3)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 482
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                if la_ == 1:
                    self.state = 469
                    self.command3ver1()
                    pass

                elif la_ == 2:
                    self.state = 470
                    self.command3ver2()
                    pass

                elif la_ == 3:
                    self.state = 471
                    self.command3ver3()
                    pass

                elif la_ == 4:
                    self.state = 472
                    self.command3ver4()
                    pass

                elif la_ == 5:
                    self.state = 473
                    self.commandCustomClick()
                    pass

                elif la_ == 6:
                    self.state = 474
                    self.commandCustomLongClick()
                    pass

                elif la_ == 7:
                    self.state = 475
                    self.commandCustomDrag()
                    pass

                elif la_ == 8:
                    self.state = 476
                    self.commandCustomType()
                    pass

                elif la_ == 9:
                    self.state = 477
                    self.commandCustomBack()
                    pass

                elif la_ == 10:
                    self.state = 478
                    self.commandCustomSleep()
                    pass

                elif la_ == 11:
                    self.state = 479
                    self.testCustom()
                    pass

                elif la_ == 12:
                    self.state = 480
                    self.commandCustomAssertText()
                    pass

                elif la_ == 13:
                    self.state = 481
                    self.commandCustomClickText()
                    pass


                self.state = 484
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 488 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.INPUT) | (1 << scriptingLanguageParser.CLICK) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE) | (1 << scriptingLanguageParser.CLEAR))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command3ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command3ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def INPUT(self):
            return self.getToken(scriptingLanguageParser.INPUT, 0)

        def NAME(self):
            return self.getToken(scriptingLanguageParser.NAME, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command3ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand3ver1"):
                listener.enterCommand3ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand3ver1"):
                listener.exitCommand3ver1(self)




    def command3ver1(self):

        localctx = scriptingLanguageParser.Command3ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_command3ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 490
            self.match(scriptingLanguageParser.INPUT)
            self.state = 491
            self.match(scriptingLanguageParser.NAME)
            self.state = 492
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command3ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command3ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def INPUT(self):
            return self.getToken(scriptingLanguageParser.INPUT, 0)

        def PASSWORD(self):
            return self.getToken(scriptingLanguageParser.PASSWORD, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command3ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand3ver2"):
                listener.enterCommand3ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand3ver2"):
                listener.exitCommand3ver2(self)




    def command3ver2(self):

        localctx = scriptingLanguageParser.Command3ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_command3ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 494
            self.match(scriptingLanguageParser.INPUT)
            self.state = 495
            self.match(scriptingLanguageParser.PASSWORD)
            self.state = 496
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command3ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command3ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def NEXT(self):
            return self.getToken(scriptingLanguageParser.NEXT, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command3ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand3ver3"):
                listener.enterCommand3ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand3ver3"):
                listener.exitCommand3ver3(self)




    def command3ver3(self):

        localctx = scriptingLanguageParser.Command3ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_command3ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 498
            self.match(scriptingLanguageParser.CLICK)
            self.state = 499
            self.match(scriptingLanguageParser.NEXT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command3ver4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command3ver4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLEAR(self):
            return self.getToken(scriptingLanguageParser.CLEAR, 0)

        def FIELDS(self):
            return self.getToken(scriptingLanguageParser.FIELDS, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command3ver4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand3ver4"):
                listener.enterCommand3ver4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand3ver4"):
                listener.exitCommand3ver4(self)




    def command3ver4(self):

        localctx = scriptingLanguageParser.Command3ver4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_command3ver4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 501
            self.match(scriptingLanguageParser.CLEAR)
            self.state = 502
            self.match(scriptingLanguageParser.FIELDS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command4ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver1Context,i)


        def command4ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver2Context,i)


        def command4ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver3Context,i)


        def command4ver4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver4Context,i)


        def command4ver5(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver5Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver5Context,i)


        def command4ver6(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver6Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver6Context,i)


        def command4ver7(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command4ver7Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command4ver7Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist4"):
                listener.enterCommandlist4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist4"):
                listener.exitCommandlist4(self)




    def commandlist4(self):

        localctx = scriptingLanguageParser.Commandlist4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_commandlist4)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 524 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 520
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
                if la_ == 1:
                    self.state = 504
                    self.command4ver1()
                    pass

                elif la_ == 2:
                    self.state = 505
                    self.command4ver2()
                    pass

                elif la_ == 3:
                    self.state = 506
                    self.command4ver3()
                    pass

                elif la_ == 4:
                    self.state = 507
                    self.command4ver4()
                    pass

                elif la_ == 5:
                    self.state = 508
                    self.command4ver5()
                    pass

                elif la_ == 6:
                    self.state = 509
                    self.command4ver6()
                    pass

                elif la_ == 7:
                    self.state = 510
                    self.command4ver7()
                    pass

                elif la_ == 8:
                    self.state = 511
                    self.commandCustomClick()
                    pass

                elif la_ == 9:
                    self.state = 512
                    self.commandCustomLongClick()
                    pass

                elif la_ == 10:
                    self.state = 513
                    self.commandCustomDrag()
                    pass

                elif la_ == 11:
                    self.state = 514
                    self.commandCustomType()
                    pass

                elif la_ == 12:
                    self.state = 515
                    self.commandCustomBack()
                    pass

                elif la_ == 13:
                    self.state = 516
                    self.commandCustomSleep()
                    pass

                elif la_ == 14:
                    self.state = 517
                    self.testCustom()
                    pass

                elif la_ == 15:
                    self.state = 518
                    self.commandCustomAssertText()
                    pass

                elif la_ == 16:
                    self.state = 519
                    self.commandCustomClickText()
                    pass


                self.state = 522
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 526 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.CLICK) | (1 << scriptingLanguageParser.PRESS) | (1 << scriptingLanguageParser.LONG) | (1 << scriptingLanguageParser.TOGGLE) | (1 << scriptingLanguageParser.SWIPE) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def LINE(self):
            return self.getToken(scriptingLanguageParser.LINE, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver1"):
                listener.enterCommand4ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver1"):
                listener.exitCommand4ver1(self)




    def command4ver1(self):

        localctx = scriptingLanguageParser.Command4ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_command4ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 528
            self.match(scriptingLanguageParser.CLICK)
            self.state = 529
            self.match(scriptingLanguageParser.LINE)
            self.state = 530
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def TOGGLE(self):
            return self.getToken(scriptingLanguageParser.TOGGLE, 0)

        def LINE(self):
            return self.getToken(scriptingLanguageParser.LINE, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver2"):
                listener.enterCommand4ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver2"):
                listener.exitCommand4ver2(self)




    def command4ver2(self):

        localctx = scriptingLanguageParser.Command4ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_command4ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 532
            self.match(scriptingLanguageParser.TOGGLE)
            self.state = 533
            self.match(scriptingLanguageParser.LINE)
            self.state = 534
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def LONG(self):
            return self.getToken(scriptingLanguageParser.LONG, 0)

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def LINE(self):
            return self.getToken(scriptingLanguageParser.LINE, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver3"):
                listener.enterCommand4ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver3"):
                listener.exitCommand4ver3(self)




    def command4ver3(self):

        localctx = scriptingLanguageParser.Command4ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_command4ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 536
            self.match(scriptingLanguageParser.LONG)
            self.state = 537
            self.match(scriptingLanguageParser.CLICK)
            self.state = 538
            self.match(scriptingLanguageParser.LINE)
            self.state = 539
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def LONG(self):
            return self.getToken(scriptingLanguageParser.LONG, 0)

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def ALL(self):
            return self.getToken(scriptingLanguageParser.ALL, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver4"):
                listener.enterCommand4ver4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver4"):
                listener.exitCommand4ver4(self)




    def command4ver4(self):

        localctx = scriptingLanguageParser.Command4ver4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_command4ver4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 541
            self.match(scriptingLanguageParser.LONG)
            self.state = 542
            self.match(scriptingLanguageParser.CLICK)
            self.state = 543
            self.match(scriptingLanguageParser.ALL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def BACK(self):
            return self.getToken(scriptingLanguageParser.BACK, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver5

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver5"):
                listener.enterCommand4ver5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver5"):
                listener.exitCommand4ver5(self)




    def command4ver5(self):

        localctx = scriptingLanguageParser.Command4ver5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_command4ver5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 545
            self.match(scriptingLanguageParser.PRESS)
            self.state = 546
            self.match(scriptingLanguageParser.BACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def UP(self):
            return self.getToken(scriptingLanguageParser.UP, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver6

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver6"):
                listener.enterCommand4ver6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver6"):
                listener.exitCommand4ver6(self)




    def command4ver6(self):

        localctx = scriptingLanguageParser.Command4ver6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_command4ver6)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 548
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 549
            self.match(scriptingLanguageParser.UP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command4ver7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command4ver7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def DOWN(self):
            return self.getToken(scriptingLanguageParser.DOWN, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command4ver7

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand4ver7"):
                listener.enterCommand4ver7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand4ver7"):
                listener.exitCommand4ver7(self)




    def command4ver7(self):

        localctx = scriptingLanguageParser.Command4ver7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_command4ver7)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 552
            self.match(scriptingLanguageParser.DOWN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command5ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command5ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command5ver1Context,i)


        def command5ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command5ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command5ver2Context,i)


        def command5ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command5ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command5ver3Context,i)


        def command5ver4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command5ver4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command5ver4Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist5

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist5"):
                listener.enterCommandlist5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist5"):
                listener.exitCommandlist5(self)




    def commandlist5(self):

        localctx = scriptingLanguageParser.Commandlist5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_commandlist5)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 571 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 567
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 554
                    self.command5ver1()
                    pass

                elif la_ == 2:
                    self.state = 555
                    self.command5ver2()
                    pass

                elif la_ == 3:
                    self.state = 556
                    self.command5ver3()
                    pass

                elif la_ == 4:
                    self.state = 557
                    self.command5ver4()
                    pass

                elif la_ == 5:
                    self.state = 558
                    self.commandCustomClick()
                    pass

                elif la_ == 6:
                    self.state = 559
                    self.commandCustomLongClick()
                    pass

                elif la_ == 7:
                    self.state = 560
                    self.commandCustomDrag()
                    pass

                elif la_ == 8:
                    self.state = 561
                    self.commandCustomType()
                    pass

                elif la_ == 9:
                    self.state = 562
                    self.commandCustomBack()
                    pass

                elif la_ == 10:
                    self.state = 563
                    self.commandCustomSleep()
                    pass

                elif la_ == 11:
                    self.state = 564
                    self.testCustom()
                    pass

                elif la_ == 12:
                    self.state = 565
                    self.commandCustomAssertText()
                    pass

                elif la_ == 13:
                    self.state = 566
                    self.commandCustomClickText()
                    pass


                self.state = 569
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 573 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.SWIPE) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command5ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command5ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def UP(self):
            return self.getToken(scriptingLanguageParser.UP, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command5ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand5ver1"):
                listener.enterCommand5ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand5ver1"):
                listener.exitCommand5ver1(self)




    def command5ver1(self):

        localctx = scriptingLanguageParser.Command5ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_command5ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 575
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 576
            self.match(scriptingLanguageParser.UP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command5ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command5ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def DOWN(self):
            return self.getToken(scriptingLanguageParser.DOWN, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command5ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand5ver2"):
                listener.enterCommand5ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand5ver2"):
                listener.exitCommand5ver2(self)




    def command5ver2(self):

        localctx = scriptingLanguageParser.Command5ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_command5ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 579
            self.match(scriptingLanguageParser.DOWN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command5ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command5ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def LEFT(self):
            return self.getToken(scriptingLanguageParser.LEFT, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command5ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand5ver3"):
                listener.enterCommand5ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand5ver3"):
                listener.exitCommand5ver3(self)




    def command5ver3(self):

        localctx = scriptingLanguageParser.Command5ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_command5ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 581
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 582
            self.match(scriptingLanguageParser.LEFT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command5ver4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command5ver4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def RIGHT(self):
            return self.getToken(scriptingLanguageParser.RIGHT, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command5ver4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand5ver4"):
                listener.enterCommand5ver4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand5ver4"):
                listener.exitCommand5ver4(self)




    def command5ver4(self):

        localctx = scriptingLanguageParser.Command5ver4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_command5ver4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 584
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 585
            self.match(scriptingLanguageParser.RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command6ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command6ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command6ver1Context,i)


        def command6ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command6ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command6ver2Context,i)


        def command6ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command6ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command6ver3Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist6

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist6"):
                listener.enterCommandlist6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist6"):
                listener.exitCommandlist6(self)




    def commandlist6(self):

        localctx = scriptingLanguageParser.Commandlist6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_commandlist6)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 603 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 599
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                if la_ == 1:
                    self.state = 587
                    self.command6ver1()
                    pass

                elif la_ == 2:
                    self.state = 588
                    self.command6ver2()
                    pass

                elif la_ == 3:
                    self.state = 589
                    self.command6ver3()
                    pass

                elif la_ == 4:
                    self.state = 590
                    self.commandCustomClick()
                    pass

                elif la_ == 5:
                    self.state = 591
                    self.commandCustomLongClick()
                    pass

                elif la_ == 6:
                    self.state = 592
                    self.commandCustomDrag()
                    pass

                elif la_ == 7:
                    self.state = 593
                    self.commandCustomType()
                    pass

                elif la_ == 8:
                    self.state = 594
                    self.commandCustomBack()
                    pass

                elif la_ == 9:
                    self.state = 595
                    self.commandCustomSleep()
                    pass

                elif la_ == 10:
                    self.state = 596
                    self.testCustom()
                    pass

                elif la_ == 11:
                    self.state = 597
                    self.commandCustomAssertText()
                    pass

                elif la_ == 12:
                    self.state = 598
                    self.commandCustomClickText()
                    pass


                self.state = 601
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 605 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.INPUT) | (1 << scriptingLanguageParser.PRESS) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command6ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command6ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def INPUT(self):
            return self.getToken(scriptingLanguageParser.INPUT, 0)

        def URL(self):
            return self.getToken(scriptingLanguageParser.URL, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command6ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand6ver1"):
                listener.enterCommand6ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand6ver1"):
                listener.exitCommand6ver1(self)




    def command6ver1(self):

        localctx = scriptingLanguageParser.Command6ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_command6ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607
            self.match(scriptingLanguageParser.INPUT)
            self.state = 608
            self.match(scriptingLanguageParser.URL)
            self.state = 609
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command6ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command6ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def ENTER(self):
            return self.getToken(scriptingLanguageParser.ENTER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command6ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand6ver2"):
                listener.enterCommand6ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand6ver2"):
                listener.exitCommand6ver2(self)




    def command6ver2(self):

        localctx = scriptingLanguageParser.Command6ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_command6ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 611
            self.match(scriptingLanguageParser.PRESS)
            self.state = 612
            self.match(scriptingLanguageParser.ENTER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command6ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command6ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def BACK(self):
            return self.getToken(scriptingLanguageParser.BACK, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command6ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand6ver3"):
                listener.enterCommand6ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand6ver3"):
                listener.exitCommand6ver3(self)




    def command6ver3(self):

        localctx = scriptingLanguageParser.Command6ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_command6ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 614
            self.match(scriptingLanguageParser.PRESS)
            self.state = 615
            self.match(scriptingLanguageParser.BACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command7ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver1Context,i)


        def command7ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver2Context,i)


        def command7ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver3Context,i)


        def command7ver4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver4Context,i)


        def command7ver5(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver5Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver5Context,i)


        def command7ver6(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver6Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver6Context,i)


        def command7ver7(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command7ver7Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command7ver7Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist7

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist7"):
                listener.enterCommandlist7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist7"):
                listener.exitCommandlist7(self)




    def commandlist7(self):

        localctx = scriptingLanguageParser.Commandlist7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_commandlist7)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 633
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
                if la_ == 1:
                    self.state = 617
                    self.command7ver1()
                    pass

                elif la_ == 2:
                    self.state = 618
                    self.command7ver2()
                    pass

                elif la_ == 3:
                    self.state = 619
                    self.command7ver3()
                    pass

                elif la_ == 4:
                    self.state = 620
                    self.command7ver4()
                    pass

                elif la_ == 5:
                    self.state = 621
                    self.command7ver5()
                    pass

                elif la_ == 6:
                    self.state = 622
                    self.command7ver6()
                    pass

                elif la_ == 7:
                    self.state = 623
                    self.command7ver7()
                    pass

                elif la_ == 8:
                    self.state = 624
                    self.commandCustomClick()
                    pass

                elif la_ == 9:
                    self.state = 625
                    self.commandCustomLongClick()
                    pass

                elif la_ == 10:
                    self.state = 626
                    self.commandCustomDrag()
                    pass

                elif la_ == 11:
                    self.state = 627
                    self.commandCustomType()
                    pass

                elif la_ == 12:
                    self.state = 628
                    self.commandCustomBack()
                    pass

                elif la_ == 13:
                    self.state = 629
                    self.commandCustomSleep()
                    pass

                elif la_ == 14:
                    self.state = 630
                    self.testCustom()
                    pass

                elif la_ == 15:
                    self.state = 631
                    self.commandCustomAssertText()
                    pass

                elif la_ == 16:
                    self.state = 632
                    self.commandCustomClickText()
                    pass


                self.state = 635
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 639 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.INPUT) | (1 << scriptingLanguageParser.CLICK) | (1 << scriptingLanguageParser.LONG) | (1 << scriptingLanguageParser.SWIPE) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def INPUT(self):
            return self.getToken(scriptingLanguageParser.INPUT, 0)

        def SEARCH(self):
            return self.getToken(scriptingLanguageParser.SEARCH, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver1"):
                listener.enterCommand7ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver1"):
                listener.exitCommand7ver1(self)




    def command7ver1(self):

        localctx = scriptingLanguageParser.Command7ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_command7ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 641
            self.match(scriptingLanguageParser.INPUT)
            self.state = 642
            self.match(scriptingLanguageParser.SEARCH)
            self.state = 643
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def UP(self):
            return self.getToken(scriptingLanguageParser.UP, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver2"):
                listener.enterCommand7ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver2"):
                listener.exitCommand7ver2(self)




    def command7ver2(self):

        localctx = scriptingLanguageParser.Command7ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_command7ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 645
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 646
            self.match(scriptingLanguageParser.UP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def DOWN(self):
            return self.getToken(scriptingLanguageParser.DOWN, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver3"):
                listener.enterCommand7ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver3"):
                listener.exitCommand7ver3(self)




    def command7ver3(self):

        localctx = scriptingLanguageParser.Command7ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_command7ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 649
            self.match(scriptingLanguageParser.DOWN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def LEFT(self):
            return self.getToken(scriptingLanguageParser.LEFT, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver4"):
                listener.enterCommand7ver4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver4"):
                listener.exitCommand7ver4(self)




    def command7ver4(self):

        localctx = scriptingLanguageParser.Command7ver4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_command7ver4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 651
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 652
            self.match(scriptingLanguageParser.LEFT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def RIGHT(self):
            return self.getToken(scriptingLanguageParser.RIGHT, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver5

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver5"):
                listener.enterCommand7ver5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver5"):
                listener.exitCommand7ver5(self)




    def command7ver5(self):

        localctx = scriptingLanguageParser.Command7ver5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_command7ver5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 654
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 655
            self.match(scriptingLanguageParser.RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver6Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver6Context, self).__init__(parent, invokingState)
            self.parser = parser

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def CENTER(self):
            return self.getToken(scriptingLanguageParser.CENTER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver6

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver6"):
                listener.enterCommand7ver6(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver6"):
                listener.exitCommand7ver6(self)




    def command7ver6(self):

        localctx = scriptingLanguageParser.Command7ver6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_command7ver6)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 657
            self.match(scriptingLanguageParser.CLICK)
            self.state = 658
            self.match(scriptingLanguageParser.CENTER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command7ver7Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command7ver7Context, self).__init__(parent, invokingState)
            self.parser = parser

        def LONG(self):
            return self.getToken(scriptingLanguageParser.LONG, 0)

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def CENTER(self):
            return self.getToken(scriptingLanguageParser.CENTER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command7ver7

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand7ver7"):
                listener.enterCommand7ver7(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand7ver7"):
                listener.exitCommand7ver7(self)




    def command7ver7(self):

        localctx = scriptingLanguageParser.Command7ver7Context(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_command7ver7)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 660
            self.match(scriptingLanguageParser.LONG)
            self.state = 661
            self.match(scriptingLanguageParser.CLICK)
            self.state = 662
            self.match(scriptingLanguageParser.CENTER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Commandlist8Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Commandlist8Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SEMICOL(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.SEMICOL)
            else:
                return self.getToken(scriptingLanguageParser.SEMICOL, i)

        def command8ver1(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command8ver1Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command8ver1Context,i)


        def command8ver2(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command8ver2Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command8ver2Context,i)


        def command8ver3(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command8ver3Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command8ver3Context,i)


        def command8ver4(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command8ver4Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command8ver4Context,i)


        def command8ver5(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.Command8ver5Context)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.Command8ver5Context,i)


        def commandCustomClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickContext,i)


        def commandCustomLongClick(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomLongClickContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomLongClickContext,i)


        def commandCustomDrag(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomDragContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomDragContext,i)


        def commandCustomType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomTypeContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomTypeContext,i)


        def commandCustomBack(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomBackContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomBackContext,i)


        def commandCustomSleep(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomSleepContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomSleepContext,i)


        def testCustom(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.TestCustomContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.TestCustomContext,i)


        def commandCustomAssertText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomAssertTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomAssertTextContext,i)


        def commandCustomClickText(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CommandCustomClickTextContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CommandCustomClickTextContext,i)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandlist8

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandlist8"):
                listener.enterCommandlist8(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandlist8"):
                listener.exitCommandlist8(self)




    def commandlist8(self):

        localctx = scriptingLanguageParser.Commandlist8Context(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_commandlist8)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 682 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 678
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
                if la_ == 1:
                    self.state = 664
                    self.command8ver1()
                    pass

                elif la_ == 2:
                    self.state = 665
                    self.command8ver2()
                    pass

                elif la_ == 3:
                    self.state = 666
                    self.command8ver3()
                    pass

                elif la_ == 4:
                    self.state = 667
                    self.command8ver4()
                    pass

                elif la_ == 5:
                    self.state = 668
                    self.command8ver5()
                    pass

                elif la_ == 6:
                    self.state = 669
                    self.commandCustomClick()
                    pass

                elif la_ == 7:
                    self.state = 670
                    self.commandCustomLongClick()
                    pass

                elif la_ == 8:
                    self.state = 671
                    self.commandCustomDrag()
                    pass

                elif la_ == 9:
                    self.state = 672
                    self.commandCustomType()
                    pass

                elif la_ == 10:
                    self.state = 673
                    self.commandCustomBack()
                    pass

                elif la_ == 11:
                    self.state = 674
                    self.commandCustomSleep()
                    pass

                elif la_ == 12:
                    self.state = 675
                    self.testCustom()
                    pass

                elif la_ == 13:
                    self.state = 676
                    self.commandCustomAssertText()
                    pass

                elif la_ == 14:
                    self.state = 677
                    self.commandCustomClickText()
                    pass


                self.state = 680
                self.match(scriptingLanguageParser.SEMICOL)
                self.state = 684 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << scriptingLanguageParser.INPUT) | (1 << scriptingLanguageParser.PRESS) | (1 << scriptingLanguageParser.SWIPE) | (1 << scriptingLanguageParser.CUSTOM) | (1 << scriptingLanguageParser.EXECUTE))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command8ver1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command8ver1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def INPUT(self):
            return self.getToken(scriptingLanguageParser.INPUT, 0)

        def MESSAGE(self):
            return self.getToken(scriptingLanguageParser.MESSAGE, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command8ver1

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand8ver1"):
                listener.enterCommand8ver1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand8ver1"):
                listener.exitCommand8ver1(self)




    def command8ver1(self):

        localctx = scriptingLanguageParser.Command8ver1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_command8ver1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 686
            self.match(scriptingLanguageParser.INPUT)
            self.state = 687
            self.match(scriptingLanguageParser.MESSAGE)
            self.state = 688
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command8ver2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command8ver2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def ENTER(self):
            return self.getToken(scriptingLanguageParser.ENTER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command8ver2

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand8ver2"):
                listener.enterCommand8ver2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand8ver2"):
                listener.exitCommand8ver2(self)




    def command8ver2(self):

        localctx = scriptingLanguageParser.Command8ver2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_command8ver2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 690
            self.match(scriptingLanguageParser.PRESS)
            self.state = 691
            self.match(scriptingLanguageParser.ENTER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command8ver3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command8ver3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def BACK(self):
            return self.getToken(scriptingLanguageParser.BACK, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command8ver3

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand8ver3"):
                listener.enterCommand8ver3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand8ver3"):
                listener.exitCommand8ver3(self)




    def command8ver3(self):

        localctx = scriptingLanguageParser.Command8ver3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_command8ver3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 693
            self.match(scriptingLanguageParser.PRESS)
            self.state = 694
            self.match(scriptingLanguageParser.BACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command8ver4Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command8ver4Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def UP(self):
            return self.getToken(scriptingLanguageParser.UP, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command8ver4

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand8ver4"):
                listener.enterCommand8ver4(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand8ver4"):
                listener.exitCommand8ver4(self)




    def command8ver4(self):

        localctx = scriptingLanguageParser.Command8ver4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_command8ver4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 696
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 697
            self.match(scriptingLanguageParser.UP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Command8ver5Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.Command8ver5Context, self).__init__(parent, invokingState)
            self.parser = parser

        def SWIPE(self):
            return self.getToken(scriptingLanguageParser.SWIPE, 0)

        def DOWN(self):
            return self.getToken(scriptingLanguageParser.DOWN, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_command8ver5

        def enterRule(self, listener):
            if hasattr(listener, "enterCommand8ver5"):
                listener.enterCommand8ver5(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommand8ver5"):
                listener.exitCommand8ver5(self)




    def command8ver5(self):

        localctx = scriptingLanguageParser.Command8ver5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_command8ver5)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 699
            self.match(scriptingLanguageParser.SWIPE)
            self.state = 700
            self.match(scriptingLanguageParser.DOWN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomClickContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomClickContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def coordinate(self):
            return self.getTypedRuleContext(scriptingLanguageParser.CoordinateContext,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomClick

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomClick"):
                listener.enterCommandCustomClick(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomClick"):
                listener.exitCommandCustomClick(self)




    def commandCustomClick(self):

        localctx = scriptingLanguageParser.CommandCustomClickContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_commandCustomClick)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 702
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 703
            self.match(scriptingLanguageParser.CLICK)
            self.state = 704
            self.coordinate()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomLongClickContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomLongClickContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def LONG(self):
            return self.getToken(scriptingLanguageParser.LONG, 0)

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def coordinate(self):
            return self.getTypedRuleContext(scriptingLanguageParser.CoordinateContext,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomLongClick

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomLongClick"):
                listener.enterCommandCustomLongClick(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomLongClick"):
                listener.exitCommandCustomLongClick(self)




    def commandCustomLongClick(self):

        localctx = scriptingLanguageParser.CommandCustomLongClickContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_commandCustomLongClick)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 706
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 707
            self.match(scriptingLanguageParser.LONG)
            self.state = 708
            self.match(scriptingLanguageParser.CLICK)
            self.state = 709
            self.coordinate()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomDragContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomDragContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def DRAG(self):
            return self.getToken(scriptingLanguageParser.DRAG, 0)

        def FROM(self):
            return self.getToken(scriptingLanguageParser.FROM, 0)

        def coordinate(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(scriptingLanguageParser.CoordinateContext)
            else:
                return self.getTypedRuleContext(scriptingLanguageParser.CoordinateContext,i)


        def TO(self):
            return self.getToken(scriptingLanguageParser.TO, 0)

        def DURATION(self):
            return self.getToken(scriptingLanguageParser.DURATION, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomDrag

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomDrag"):
                listener.enterCommandCustomDrag(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomDrag"):
                listener.exitCommandCustomDrag(self)




    def commandCustomDrag(self):

        localctx = scriptingLanguageParser.CommandCustomDragContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_commandCustomDrag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 711
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 712
            self.match(scriptingLanguageParser.DRAG)
            self.state = 713
            self.match(scriptingLanguageParser.FROM)
            self.state = 714
            self.coordinate()
            self.state = 715
            self.match(scriptingLanguageParser.TO)
            self.state = 716
            self.coordinate()
            self.state = 717
            self.match(scriptingLanguageParser.DURATION)
            self.state = 718
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomTypeContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomTypeContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def TYPE(self):
            return self.getToken(scriptingLanguageParser.TYPE, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomType

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomType"):
                listener.enterCommandCustomType(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomType"):
                listener.exitCommandCustomType(self)




    def commandCustomType(self):

        localctx = scriptingLanguageParser.CommandCustomTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_commandCustomType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 721
            self.match(scriptingLanguageParser.TYPE)
            self.state = 722
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomBackContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomBackContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def PRESS(self):
            return self.getToken(scriptingLanguageParser.PRESS, 0)

        def DEVICE(self):
            return self.getToken(scriptingLanguageParser.DEVICE, 0)

        def BACK(self):
            return self.getToken(scriptingLanguageParser.BACK, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomBack

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomBack"):
                listener.enterCommandCustomBack(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomBack"):
                listener.exitCommandCustomBack(self)




    def commandCustomBack(self):

        localctx = scriptingLanguageParser.CommandCustomBackContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_commandCustomBack)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 724
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 725
            self.match(scriptingLanguageParser.PRESS)
            self.state = 726
            self.match(scriptingLanguageParser.DEVICE)
            self.state = 727
            self.match(scriptingLanguageParser.BACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomSleepContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomSleepContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def SLEEP(self):
            return self.getToken(scriptingLanguageParser.SLEEP, 0)

        def NUMBER(self):
            return self.getToken(scriptingLanguageParser.NUMBER, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomSleep

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomSleep"):
                listener.enterCommandCustomSleep(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomSleep"):
                listener.exitCommandCustomSleep(self)




    def commandCustomSleep(self):

        localctx = scriptingLanguageParser.CommandCustomSleepContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_commandCustomSleep)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 729
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 730
            self.match(scriptingLanguageParser.SLEEP)
            self.state = 731
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomAssertTextContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomAssertTextContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def ASSERT(self):
            return self.getToken(scriptingLanguageParser.ASSERT, 0)

        def TEXT(self):
            return self.getToken(scriptingLanguageParser.TEXT, 0)

        def EQUALS(self):
            return self.getToken(scriptingLanguageParser.EQUALS, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomAssertText

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomAssertText"):
                listener.enterCommandCustomAssertText(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomAssertText"):
                listener.exitCommandCustomAssertText(self)




    def commandCustomAssertText(self):

        localctx = scriptingLanguageParser.CommandCustomAssertTextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_commandCustomAssertText)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 733
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 734
            self.match(scriptingLanguageParser.ASSERT)
            self.state = 735
            self.match(scriptingLanguageParser.TEXT)
            self.state = 736
            self.match(scriptingLanguageParser.EQUALS)
            self.state = 737
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandCustomClickTextContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CommandCustomClickTextContext, self).__init__(parent, invokingState)
            self.parser = parser

        def CUSTOM(self):
            return self.getToken(scriptingLanguageParser.CUSTOM, 0)

        def CLICK(self):
            return self.getToken(scriptingLanguageParser.CLICK, 0)

        def TEXT(self):
            return self.getToken(scriptingLanguageParser.TEXT, 0)

        def QUOTEDSTRING(self):
            return self.getToken(scriptingLanguageParser.QUOTEDSTRING, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_commandCustomClickText

        def enterRule(self, listener):
            if hasattr(listener, "enterCommandCustomClickText"):
                listener.enterCommandCustomClickText(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCommandCustomClickText"):
                listener.exitCommandCustomClickText(self)




    def commandCustomClickText(self):

        localctx = scriptingLanguageParser.CommandCustomClickTextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_commandCustomClickText)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 739
            self.match(scriptingLanguageParser.CUSTOM)
            self.state = 740
            self.match(scriptingLanguageParser.CLICK)
            self.state = 741
            self.match(scriptingLanguageParser.TEXT)
            self.state = 742
            self.match(scriptingLanguageParser.QUOTEDSTRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CoordinateContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.CoordinateContext, self).__init__(parent, invokingState)
            self.parser = parser

        def NUMBER(self, i=None):
            if i is None:
                return self.getTokens(scriptingLanguageParser.NUMBER)
            else:
                return self.getToken(scriptingLanguageParser.NUMBER, i)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_coordinate

        def enterRule(self, listener):
            if hasattr(listener, "enterCoordinate"):
                listener.enterCoordinate(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitCoordinate"):
                listener.exitCoordinate(self)




    def coordinate(self):

        localctx = scriptingLanguageParser.CoordinateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_coordinate)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.match(scriptingLanguageParser.NUMBER)
            self.state = 745
            self.match(scriptingLanguageParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TestCustomContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.TestCustomContext, self).__init__(parent, invokingState)
            self.parser = parser

        def EXECUTE(self):
            return self.getToken(scriptingLanguageParser.EXECUTE, 0)

        def testSlot1(self):
            return self.getTypedRuleContext(scriptingLanguageParser.TestSlot1Context,0)


        def testSlot2(self):
            return self.getTypedRuleContext(scriptingLanguageParser.TestSlot2Context,0)


        def testSlot3(self):
            return self.getTypedRuleContext(scriptingLanguageParser.TestSlot3Context,0)


        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testCustom

        def enterRule(self, listener):
            if hasattr(listener, "enterTestCustom"):
                listener.enterTestCustom(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestCustom"):
                listener.exitTestCustom(self)




    def testCustom(self):

        localctx = scriptingLanguageParser.TestCustomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_testCustom)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 747
            self.match(scriptingLanguageParser.EXECUTE)
            self.state = 751
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [scriptingLanguageParser.TESTSLOT1]:
                self.state = 748
                self.testSlot1()
                pass
            elif token in [scriptingLanguageParser.TESTSLOT2]:
                self.state = 749
                self.testSlot2()
                pass
            elif token in [scriptingLanguageParser.TESTSLOT3]:
                self.state = 750
                self.testSlot3()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TestSlot1Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.TestSlot1Context, self).__init__(parent, invokingState)
            self.parser = parser

        def TESTSLOT1(self):
            return self.getToken(scriptingLanguageParser.TESTSLOT1, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testSlot1

        def enterRule(self, listener):
            if hasattr(listener, "enterTestSlot1"):
                listener.enterTestSlot1(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestSlot1"):
                listener.exitTestSlot1(self)




    def testSlot1(self):

        localctx = scriptingLanguageParser.TestSlot1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_testSlot1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 753
            self.match(scriptingLanguageParser.TESTSLOT1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TestSlot2Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.TestSlot2Context, self).__init__(parent, invokingState)
            self.parser = parser

        def TESTSLOT2(self):
            return self.getToken(scriptingLanguageParser.TESTSLOT2, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testSlot2

        def enterRule(self, listener):
            if hasattr(listener, "enterTestSlot2"):
                listener.enterTestSlot2(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestSlot2"):
                listener.exitTestSlot2(self)




    def testSlot2(self):

        localctx = scriptingLanguageParser.TestSlot2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_testSlot2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 755
            self.match(scriptingLanguageParser.TESTSLOT2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TestSlot3Context(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(scriptingLanguageParser.TestSlot3Context, self).__init__(parent, invokingState)
            self.parser = parser

        def TESTSLOT3(self):
            return self.getToken(scriptingLanguageParser.TESTSLOT3, 0)

        def getRuleIndex(self):
            return scriptingLanguageParser.RULE_testSlot3

        def enterRule(self, listener):
            if hasattr(listener, "enterTestSlot3"):
                listener.enterTestSlot3(self)

        def exitRule(self, listener):
            if hasattr(listener, "exitTestSlot3"):
                listener.exitTestSlot3(self)




    def testSlot3(self):

        localctx = scriptingLanguageParser.TestSlot3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_testSlot3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 757
            self.match(scriptingLanguageParser.TESTSLOT3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





