// Generated from src/antlr/Certus.g4 by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { CertusListener } from "./CertusListener";
import { CertusVisitor } from "./CertusVisitor";


export class CertusParser extends Parser {
	public static readonly T__0 = 1;
	public static readonly T__1 = 2;
	public static readonly T__2 = 3;
	public static readonly T__3 = 4;
	public static readonly T__4 = 5;
	public static readonly T__5 = 6;
	public static readonly T__6 = 7;
	public static readonly T__7 = 8;
	public static readonly T__8 = 9;
	public static readonly T__9 = 10;
	public static readonly T__10 = 11;
	public static readonly T__11 = 12;
	public static readonly T__12 = 13;
	public static readonly T__13 = 14;
	public static readonly ARROW = 15;
	public static readonly ASSIGN = 16;
	public static readonly HAS = 17;
	public static readonly CONTAIN = 18;
	public static readonly OVERLAP = 19;
	public static readonly EXACTLY = 20;
	public static readonly UNION = 21;
	public static readonly INTERSECT = 22;
	public static readonly WITH = 23;
	public static readonly GLOBAL = 24;
	public static readonly END = 25;
	public static readonly AS = 26;
	public static readonly NOT = 27;
	public static readonly INVERT = 28;
	public static readonly COMP = 29;
	public static readonly AND = 30;
	public static readonly OR = 31;
	public static readonly NEQ = 32;
	public static readonly EQ = 33;
	public static readonly GT = 34;
	public static readonly LT = 35;
	public static readonly GEQ = 36;
	public static readonly LEQ = 37;
	public static readonly MACRO_PREFIX = 38;
	public static readonly INDICATOR_PREFIX = 39;
	public static readonly ARTIFACT_PREFIX = 40;
	public static readonly CASES = 41;
	public static readonly OTHERWISE = 42;
	public static readonly FLOAT = 43;
	public static readonly ARG_SEP = 44;
	public static readonly STMT_SEP = 45;
	public static readonly ID = 46;
	public static readonly WS = 47;
	public static readonly RULE_start = 0;
	public static readonly RULE_localBind = 1;
	public static readonly RULE_globalBind = 2;
	public static readonly RULE_assignment = 3;
	public static readonly RULE_definition = 4;
	public static readonly RULE_opDef = 5;
	public static readonly RULE_opTypedParam = 6;
	public static readonly RULE_nodeType = 7;
	public static readonly RULE_booleanExpr = 8;
	public static readonly RULE_indicator = 9;
	public static readonly RULE_indicatorCategory = 10;
	public static readonly RULE_indicatorExpr = 11;
	public static readonly RULE_artifact = 12;
	public static readonly RULE_artifactExpr = 13;
	public static readonly RULE_casesExpr = 14;
	public static readonly RULE_case = 15;
	public static readonly RULE_macroExpr = 16;
	public static readonly RULE_fuzzyExpr = 17;
	public static readonly RULE_invokedOp = 18;
	public static readonly RULE_fuzzySym = 19;
	public static readonly RULE_builtInOp = 20;
	public static readonly RULE_minOp = 21;
	public static readonly RULE_maxOp = 22;
	public static readonly RULE_invertOp = 23;
	public static readonly RULE_compOp = 24;
	public static readonly RULE_defineSet = 25;
	public static readonly RULE_setTrap = 26;
	public static readonly RULE_setTri = 27;
	public static readonly RULE_setUp = 28;
	public static readonly RULE_setDown = 29;
	public static readonly RULE_setConst = 30;
	public static readonly RULE_setCrisp = 31;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"start", "localBind", "globalBind", "assignment", "definition", "opDef", 
		"opTypedParam", "nodeType", "booleanExpr", "indicator", "indicatorCategory", 
		"indicatorExpr", "artifact", "artifactExpr", "casesExpr", "case", "macroExpr", 
		"fuzzyExpr", "invokedOp", "fuzzySym", "builtInOp", "minOp", "maxOp", "invertOp", 
		"compOp", "defineSet", "setTrap", "setTri", "setUp", "setDown", "setConst", 
		"setCrisp",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "'('", "')'", "':'", "'\"'", "'min'", "'max'", "'trap'", "'tri'", 
		"'up'", "'down'", "'const'", "'['", "']'", "'crisp'", "'->'", undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		"'#'", "'$'", "'@'", undefined, undefined, undefined, "','", "';'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, "ARROW", "ASSIGN", "HAS", "CONTAIN", "OVERLAP", "EXACTLY", 
		"UNION", "INTERSECT", "WITH", "GLOBAL", "END", "AS", "NOT", "INVERT", 
		"COMP", "AND", "OR", "NEQ", "EQ", "GT", "LT", "GEQ", "LEQ", "MACRO_PREFIX", 
		"INDICATOR_PREFIX", "ARTIFACT_PREFIX", "CASES", "OTHERWISE", "FLOAT", 
		"ARG_SEP", "STMT_SEP", "ID", "WS",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(CertusParser._LITERAL_NAMES, CertusParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return CertusParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "Certus.g4"; }

	// @Override
	public get ruleNames(): string[] { return CertusParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return CertusParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(CertusParser._ATN, this);
	}
	// @RuleVersion(0)
	public start(): StartContext {
		let _localctx: StartContext = new StartContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, CertusParser.RULE_start);
		try {
			this.state = 74;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CertusParser.GLOBAL:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 64;
				this.globalBind();
				this.state = 65;
				this.match(CertusParser.EOF);
				}
				break;
			case CertusParser.WITH:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 67;
				this.localBind();
				this.state = 68;
				this.assignment();
				this.state = 69;
				this.match(CertusParser.EOF);
				}
				break;
			case CertusParser.ID:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 71;
				this.assignment();
				this.state = 72;
				this.match(CertusParser.EOF);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public localBind(): LocalBindContext {
		let _localctx: LocalBindContext = new LocalBindContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, CertusParser.RULE_localBind);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 76;
			this.match(CertusParser.WITH);
			this.state = 77;
			this.definition();
			this.state = 82;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 1, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 78;
					this.match(CertusParser.STMT_SEP);
					this.state = 79;
					this.definition();
					}
					}
				}
				this.state = 84;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 1, this._ctx);
			}
			this.state = 86;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === CertusParser.STMT_SEP) {
				{
				this.state = 85;
				this.match(CertusParser.STMT_SEP);
				}
			}

			this.state = 88;
			this.match(CertusParser.END);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public globalBind(): GlobalBindContext {
		let _localctx: GlobalBindContext = new GlobalBindContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, CertusParser.RULE_globalBind);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 90;
			this.match(CertusParser.GLOBAL);
			this.state = 91;
			this.definition();
			this.state = 96;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 3, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 92;
					this.match(CertusParser.STMT_SEP);
					this.state = 93;
					this.definition();
					}
					}
				}
				this.state = 98;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 3, this._ctx);
			}
			this.state = 100;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === CertusParser.STMT_SEP) {
				{
				this.state = 99;
				this.match(CertusParser.STMT_SEP);
				}
			}

			this.state = 102;
			this.match(CertusParser.END);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public assignment(): AssignmentContext {
		let _localctx: AssignmentContext = new AssignmentContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, CertusParser.RULE_assignment);
		try {
			this.state = 110;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 5, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 104;
				this.match(CertusParser.ID);
				this.state = 105;
				this.match(CertusParser.ASSIGN);
				this.state = 106;
				this.fuzzyExpr(0);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 107;
				this.match(CertusParser.ID);
				this.state = 108;
				this.match(CertusParser.ASSIGN);
				this.state = 109;
				this.macroExpr();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public definition(): DefinitionContext {
		let _localctx: DefinitionContext = new DefinitionContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, CertusParser.RULE_definition);
		try {
			this.state = 119;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 6, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 112;
				this.match(CertusParser.ID);
				this.state = 113;
				this.match(CertusParser.AS);
				this.state = 114;
				this.fuzzyExpr(0);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 115;
				this.opDef();
				this.state = 116;
				this.match(CertusParser.AS);
				this.state = 117;
				this.fuzzyExpr(0);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public opDef(): OpDefContext {
		let _localctx: OpDefContext = new OpDefContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, CertusParser.RULE_opDef);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 121;
			this.match(CertusParser.ID);
			this.state = 122;
			this.match(CertusParser.T__0);
			this.state = 123;
			this.opTypedParam();
			this.state = 128;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === CertusParser.ARG_SEP) {
				{
				{
				this.state = 124;
				this.match(CertusParser.ARG_SEP);
				this.state = 125;
				this.opTypedParam();
				}
				}
				this.state = 130;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 131;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public opTypedParam(): OpTypedParamContext {
		let _localctx: OpTypedParamContext = new OpTypedParamContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, CertusParser.RULE_opTypedParam);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 133;
			this.match(CertusParser.ID);
			this.state = 134;
			this.match(CertusParser.T__2);
			this.state = 135;
			this.nodeType();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public nodeType(): NodeTypeContext {
		let _localctx: NodeTypeContext = new NodeTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, CertusParser.RULE_nodeType);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 137;
			this.match(CertusParser.ID);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public booleanExpr(): BooleanExprContext;
	public booleanExpr(_p: number): BooleanExprContext;
	// @RuleVersion(0)
	public booleanExpr(_p?: number): BooleanExprContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: BooleanExprContext = new BooleanExprContext(this._ctx, _parentState);
		let _prevctx: BooleanExprContext = _localctx;
		let _startState: number = 16;
		this.enterRecursionRule(_localctx, 16, CertusParser.RULE_booleanExpr, _p);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 188;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 8, this._ctx) ) {
			case 1:
				{
				this.state = 140;
				this.match(CertusParser.T__0);
				this.state = 141;
				this.booleanExpr(0);
				this.state = 142;
				this.match(CertusParser.T__1);
				}
				break;

			case 2:
				{
				this.state = 144;
				this.indicatorExpr();
				}
				break;

			case 3:
				{
				this.state = 145;
				this.artifactExpr();
				}
				break;

			case 4:
				{
				this.state = 146;
				this.match(CertusParser.NOT);
				this.state = 147;
				this.booleanExpr(13);
				}
				break;

			case 5:
				{
				this.state = 148;
				this.fuzzyExpr(0);
				this.state = 149;
				this.match(CertusParser.LT);
				this.state = 150;
				this.fuzzyExpr(0);
				}
				break;

			case 6:
				{
				this.state = 152;
				this.fuzzyExpr(0);
				this.state = 153;
				this.match(CertusParser.LEQ);
				this.state = 154;
				this.fuzzyExpr(0);
				}
				break;

			case 7:
				{
				this.state = 156;
				this.fuzzyExpr(0);
				this.state = 157;
				this.match(CertusParser.GT);
				this.state = 158;
				this.fuzzyExpr(0);
				}
				break;

			case 8:
				{
				this.state = 160;
				this.fuzzyExpr(0);
				this.state = 161;
				this.match(CertusParser.GEQ);
				this.state = 162;
				this.fuzzyExpr(0);
				}
				break;

			case 9:
				{
				this.state = 164;
				this.fuzzyExpr(0);
				this.state = 165;
				this.match(CertusParser.EQ);
				this.state = 166;
				this.fuzzyExpr(0);
				}
				break;

			case 10:
				{
				this.state = 168;
				this.fuzzyExpr(0);
				this.state = 169;
				this.match(CertusParser.NEQ);
				this.state = 170;
				this.fuzzyExpr(0);
				}
				break;

			case 11:
				{
				this.state = 172;
				this.fuzzyExpr(0);
				this.state = 173;
				this.match(CertusParser.EXACTLY);
				this.state = 174;
				this.fuzzyExpr(0);
				}
				break;

			case 12:
				{
				this.state = 176;
				this.fuzzyExpr(0);
				this.state = 177;
				this.match(CertusParser.ASSIGN);
				this.state = 178;
				this.fuzzyExpr(0);
				}
				break;

			case 13:
				{
				this.state = 180;
				this.fuzzyExpr(0);
				this.state = 181;
				this.match(CertusParser.CONTAIN);
				this.state = 182;
				this.fuzzyExpr(0);
				}
				break;

			case 14:
				{
				this.state = 184;
				this.fuzzyExpr(0);
				this.state = 185;
				this.match(CertusParser.OVERLAP);
				this.state = 186;
				this.fuzzyExpr(0);
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 198;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 10, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 196;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
					case 1:
						{
						_localctx = new BooleanExprContext(_parentctx, _parentState);
						this.pushNewRecursionContext(_localctx, _startState, CertusParser.RULE_booleanExpr);
						this.state = 190;
						if (!(this.precpred(this._ctx, 12))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 12)");
						}
						this.state = 191;
						this.match(CertusParser.AND);
						this.state = 192;
						this.booleanExpr(13);
						}
						break;

					case 2:
						{
						_localctx = new BooleanExprContext(_parentctx, _parentState);
						this.pushNewRecursionContext(_localctx, _startState, CertusParser.RULE_booleanExpr);
						this.state = 193;
						if (!(this.precpred(this._ctx, 11))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 11)");
						}
						this.state = 194;
						this.match(CertusParser.OR);
						this.state = 195;
						this.booleanExpr(12);
						}
						break;
					}
					}
				}
				this.state = 200;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 10, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public indicator(): IndicatorContext {
		let _localctx: IndicatorContext = new IndicatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, CertusParser.RULE_indicator);
		let _la: number;
		try {
			this.state = 214;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 13, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 201;
				this.match(CertusParser.INDICATOR_PREFIX);
				this.state = 202;
				this.match(CertusParser.T__3);
				this.state = 207;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 203;
					this.match(CertusParser.ID);
					this.state = 205;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === CertusParser.WS) {
						{
						this.state = 204;
						this.match(CertusParser.WS);
						}
					}

					}
					}
					this.state = 209;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === CertusParser.ID);
				this.state = 211;
				this.match(CertusParser.T__3);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 212;
				this.match(CertusParser.INDICATOR_PREFIX);
				this.state = 213;
				this.match(CertusParser.ID);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public indicatorCategory(): IndicatorCategoryContext {
		let _localctx: IndicatorCategoryContext = new IndicatorCategoryContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, CertusParser.RULE_indicatorCategory);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 216;
			this.match(CertusParser.ID);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public indicatorExpr(): IndicatorExprContext {
		let _localctx: IndicatorExprContext = new IndicatorExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 22, CertusParser.RULE_indicatorExpr);
		let _la: number;
		try {
			this.state = 274;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 14, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 218;
				this.indicator();
				this.state = 219;
				this.match(CertusParser.ASSIGN);
				this.state = 220;
				this.indicatorCategory();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 222;
				this.indicator();
				this.state = 223;
				_la = this._input.LA(1);
				if (!(_la === CertusParser.EXACTLY || _la === CertusParser.EQ)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 224;
				this.indicator();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 226;
				this.indicator();
				this.state = 227;
				this.match(CertusParser.LT);
				this.state = 228;
				this.indicator();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 230;
				this.indicator();
				this.state = 231;
				this.match(CertusParser.LEQ);
				this.state = 232;
				this.indicator();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 234;
				this.indicator();
				this.state = 235;
				this.match(CertusParser.GT);
				this.state = 236;
				this.indicator();
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 238;
				this.indicator();
				this.state = 239;
				this.match(CertusParser.GEQ);
				this.state = 240;
				this.indicator();
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 242;
				this.indicator();
				this.state = 243;
				this.match(CertusParser.NEQ);
				this.state = 244;
				this.indicator();
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 246;
				this.indicator();
				this.state = 247;
				this.match(CertusParser.LT);
				this.state = 248;
				this.indicator();
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 250;
				this.indicator();
				this.state = 251;
				_la = this._input.LA(1);
				if (!(_la === CertusParser.EXACTLY || _la === CertusParser.EQ)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 252;
				this.match(CertusParser.FLOAT);
				}
				break;

			case 10:
				this.enterOuterAlt(_localctx, 10);
				{
				this.state = 254;
				this.indicator();
				this.state = 255;
				this.match(CertusParser.LT);
				this.state = 256;
				this.match(CertusParser.FLOAT);
				}
				break;

			case 11:
				this.enterOuterAlt(_localctx, 11);
				{
				this.state = 258;
				this.indicator();
				this.state = 259;
				this.match(CertusParser.LEQ);
				this.state = 260;
				this.match(CertusParser.FLOAT);
				}
				break;

			case 12:
				this.enterOuterAlt(_localctx, 12);
				{
				this.state = 262;
				this.indicator();
				this.state = 263;
				this.match(CertusParser.GT);
				this.state = 264;
				this.match(CertusParser.FLOAT);
				}
				break;

			case 13:
				this.enterOuterAlt(_localctx, 13);
				{
				this.state = 266;
				this.indicator();
				this.state = 267;
				this.match(CertusParser.GEQ);
				this.state = 268;
				this.match(CertusParser.FLOAT);
				}
				break;

			case 14:
				this.enterOuterAlt(_localctx, 14);
				{
				this.state = 270;
				this.indicator();
				this.state = 271;
				this.match(CertusParser.NEQ);
				this.state = 272;
				this.match(CertusParser.FLOAT);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public artifact(): ArtifactContext {
		let _localctx: ArtifactContext = new ArtifactContext(this._ctx, this.state);
		this.enterRule(_localctx, 24, CertusParser.RULE_artifact);
		let _la: number;
		try {
			this.state = 289;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 17, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 276;
				this.match(CertusParser.ARTIFACT_PREFIX);
				this.state = 277;
				this.match(CertusParser.T__3);
				this.state = 282;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 278;
					this.match(CertusParser.ID);
					this.state = 280;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === CertusParser.WS) {
						{
						this.state = 279;
						this.match(CertusParser.WS);
						}
					}

					}
					}
					this.state = 284;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === CertusParser.ID);
				this.state = 286;
				this.match(CertusParser.T__3);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 287;
				this.match(CertusParser.ARTIFACT_PREFIX);
				this.state = 288;
				this.match(CertusParser.ID);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public artifactExpr(): ArtifactExprContext {
		let _localctx: ArtifactExprContext = new ArtifactExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 26, CertusParser.RULE_artifactExpr);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 291;
			this.match(CertusParser.HAS);
			this.state = 292;
			this.artifact();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public casesExpr(): CasesExprContext {
		let _localctx: CasesExprContext = new CasesExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 28, CertusParser.RULE_casesExpr);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 294;
			this.match(CertusParser.CASES);
			this.state = 298;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 295;
				this.case();
				this.state = 296;
				this.match(CertusParser.ARG_SEP);
				}
				}
				this.state = 300;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CertusParser.T__0) | (1 << CertusParser.T__4) | (1 << CertusParser.T__5) | (1 << CertusParser.T__6) | (1 << CertusParser.T__7) | (1 << CertusParser.T__8) | (1 << CertusParser.T__9) | (1 << CertusParser.T__10) | (1 << CertusParser.T__11) | (1 << CertusParser.T__13) | (1 << CertusParser.HAS) | (1 << CertusParser.NOT) | (1 << CertusParser.INVERT) | (1 << CertusParser.COMP))) !== 0) || ((((_la - 39)) & ~0x1F) === 0 && ((1 << (_la - 39)) & ((1 << (CertusParser.INDICATOR_PREFIX - 39)) | (1 << (CertusParser.CASES - 39)) | (1 << (CertusParser.ID - 39)))) !== 0));
			this.state = 302;
			this.match(CertusParser.OTHERWISE);
			this.state = 303;
			this.fuzzyExpr(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public case(): CaseContext {
		let _localctx: CaseContext = new CaseContext(this._ctx, this.state);
		this.enterRule(_localctx, 30, CertusParser.RULE_case);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 305;
			this.booleanExpr(0);
			this.state = 306;
			this.match(CertusParser.ARROW);
			this.state = 307;
			this.fuzzyExpr(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public macroExpr(): MacroExprContext {
		let _localctx: MacroExprContext = new MacroExprContext(this._ctx, this.state);
		this.enterRule(_localctx, 32, CertusParser.RULE_macroExpr);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 309;
			this.match(CertusParser.MACRO_PREFIX);
			this.state = 310;
			this.match(CertusParser.ID);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public fuzzyExpr(): FuzzyExprContext;
	public fuzzyExpr(_p: number): FuzzyExprContext;
	// @RuleVersion(0)
	public fuzzyExpr(_p?: number): FuzzyExprContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: FuzzyExprContext = new FuzzyExprContext(this._ctx, _parentState);
		let _prevctx: FuzzyExprContext = _localctx;
		let _startState: number = 34;
		this.enterRecursionRule(_localctx, 34, CertusParser.RULE_fuzzyExpr, _p);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 318;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 19, this._ctx) ) {
			case 1:
				{
				this.state = 313;
				this.casesExpr();
				}
				break;

			case 2:
				{
				this.state = 314;
				this.defineSet();
				}
				break;

			case 3:
				{
				this.state = 315;
				this.builtInOp();
				}
				break;

			case 4:
				{
				this.state = 316;
				this.invokedOp();
				}
				break;

			case 5:
				{
				this.state = 317;
				this.fuzzySym();
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 328;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 326;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 20, this._ctx) ) {
					case 1:
						{
						_localctx = new FuzzyExprContext(_parentctx, _parentState);
						this.pushNewRecursionContext(_localctx, _startState, CertusParser.RULE_fuzzyExpr);
						this.state = 320;
						if (!(this.precpred(this._ctx, 7))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
						}
						this.state = 321;
						this.match(CertusParser.INTERSECT);
						this.state = 322;
						this.fuzzyExpr(8);
						}
						break;

					case 2:
						{
						_localctx = new FuzzyExprContext(_parentctx, _parentState);
						this.pushNewRecursionContext(_localctx, _startState, CertusParser.RULE_fuzzyExpr);
						this.state = 323;
						if (!(this.precpred(this._ctx, 6))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
						}
						this.state = 324;
						this.match(CertusParser.UNION);
						this.state = 325;
						this.fuzzyExpr(7);
						}
						break;
					}
					}
				}
				this.state = 330;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public invokedOp(): InvokedOpContext {
		let _localctx: InvokedOpContext = new InvokedOpContext(this._ctx, this.state);
		this.enterRule(_localctx, 36, CertusParser.RULE_invokedOp);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 331;
			this.match(CertusParser.ID);
			this.state = 332;
			this.match(CertusParser.T__0);
			this.state = 333;
			this.match(CertusParser.ID);
			this.state = 338;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === CertusParser.ARG_SEP) {
				{
				{
				this.state = 334;
				this.match(CertusParser.ARG_SEP);
				this.state = 335;
				this.match(CertusParser.ID);
				}
				}
				this.state = 340;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 341;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public fuzzySym(): FuzzySymContext {
		let _localctx: FuzzySymContext = new FuzzySymContext(this._ctx, this.state);
		this.enterRule(_localctx, 38, CertusParser.RULE_fuzzySym);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 343;
			this.match(CertusParser.ID);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public builtInOp(): BuiltInOpContext {
		let _localctx: BuiltInOpContext = new BuiltInOpContext(this._ctx, this.state);
		this.enterRule(_localctx, 40, CertusParser.RULE_builtInOp);
		try {
			this.state = 349;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CertusParser.T__4:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 345;
				this.minOp();
				}
				break;
			case CertusParser.T__5:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 346;
				this.maxOp();
				}
				break;
			case CertusParser.INVERT:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 347;
				this.invertOp();
				}
				break;
			case CertusParser.COMP:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 348;
				this.compOp();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public minOp(): MinOpContext {
		let _localctx: MinOpContext = new MinOpContext(this._ctx, this.state);
		this.enterRule(_localctx, 42, CertusParser.RULE_minOp);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 351;
			this.match(CertusParser.T__4);
			this.state = 352;
			this.match(CertusParser.T__0);
			this.state = 353;
			this.fuzzyExpr(0);
			this.state = 358;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === CertusParser.ARG_SEP) {
				{
				{
				this.state = 354;
				this.match(CertusParser.ARG_SEP);
				this.state = 355;
				this.fuzzyExpr(0);
				}
				}
				this.state = 360;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 361;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public maxOp(): MaxOpContext {
		let _localctx: MaxOpContext = new MaxOpContext(this._ctx, this.state);
		this.enterRule(_localctx, 44, CertusParser.RULE_maxOp);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 363;
			this.match(CertusParser.T__5);
			this.state = 364;
			this.match(CertusParser.T__0);
			this.state = 365;
			this.fuzzyExpr(0);
			this.state = 370;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === CertusParser.ARG_SEP) {
				{
				{
				this.state = 366;
				this.match(CertusParser.ARG_SEP);
				this.state = 367;
				this.fuzzyExpr(0);
				}
				}
				this.state = 372;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 373;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public invertOp(): InvertOpContext {
		let _localctx: InvertOpContext = new InvertOpContext(this._ctx, this.state);
		this.enterRule(_localctx, 46, CertusParser.RULE_invertOp);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 375;
			this.match(CertusParser.INVERT);
			this.state = 376;
			this.match(CertusParser.T__0);
			this.state = 377;
			this.fuzzyExpr(0);
			this.state = 378;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public compOp(): CompOpContext {
		let _localctx: CompOpContext = new CompOpContext(this._ctx, this.state);
		this.enterRule(_localctx, 48, CertusParser.RULE_compOp);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 380;
			this.match(CertusParser.COMP);
			this.state = 381;
			this.match(CertusParser.T__0);
			this.state = 382;
			this.fuzzyExpr(0);
			this.state = 383;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public defineSet(): DefineSetContext {
		let _localctx: DefineSetContext = new DefineSetContext(this._ctx, this.state);
		this.enterRule(_localctx, 50, CertusParser.RULE_defineSet);
		try {
			this.state = 391;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CertusParser.T__6:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 385;
				this.setTrap();
				}
				break;
			case CertusParser.T__7:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 386;
				this.setTri();
				}
				break;
			case CertusParser.T__8:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 387;
				this.setUp();
				}
				break;
			case CertusParser.T__9:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 388;
				this.setDown();
				}
				break;
			case CertusParser.T__10:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 389;
				this.setConst();
				}
				break;
			case CertusParser.T__11:
			case CertusParser.T__13:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 390;
				this.setCrisp();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setTrap(): SetTrapContext {
		let _localctx: SetTrapContext = new SetTrapContext(this._ctx, this.state);
		this.enterRule(_localctx, 52, CertusParser.RULE_setTrap);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 393;
			this.match(CertusParser.T__6);
			this.state = 394;
			this.match(CertusParser.T__0);
			this.state = 395;
			this.match(CertusParser.FLOAT);
			this.state = 396;
			this.match(CertusParser.ARG_SEP);
			this.state = 397;
			this.match(CertusParser.FLOAT);
			this.state = 398;
			this.match(CertusParser.ARG_SEP);
			this.state = 399;
			this.match(CertusParser.FLOAT);
			this.state = 400;
			this.match(CertusParser.ARG_SEP);
			this.state = 401;
			this.match(CertusParser.FLOAT);
			this.state = 402;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setTri(): SetTriContext {
		let _localctx: SetTriContext = new SetTriContext(this._ctx, this.state);
		this.enterRule(_localctx, 54, CertusParser.RULE_setTri);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 404;
			this.match(CertusParser.T__7);
			this.state = 405;
			this.match(CertusParser.T__0);
			this.state = 406;
			this.match(CertusParser.FLOAT);
			this.state = 407;
			this.match(CertusParser.ARG_SEP);
			this.state = 408;
			this.match(CertusParser.FLOAT);
			this.state = 409;
			this.match(CertusParser.ARG_SEP);
			this.state = 410;
			this.match(CertusParser.FLOAT);
			this.state = 411;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setUp(): SetUpContext {
		let _localctx: SetUpContext = new SetUpContext(this._ctx, this.state);
		this.enterRule(_localctx, 56, CertusParser.RULE_setUp);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 413;
			this.match(CertusParser.T__8);
			this.state = 414;
			this.match(CertusParser.T__0);
			this.state = 415;
			this.match(CertusParser.FLOAT);
			this.state = 416;
			this.match(CertusParser.ARG_SEP);
			this.state = 417;
			this.match(CertusParser.FLOAT);
			this.state = 418;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setDown(): SetDownContext {
		let _localctx: SetDownContext = new SetDownContext(this._ctx, this.state);
		this.enterRule(_localctx, 58, CertusParser.RULE_setDown);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 420;
			this.match(CertusParser.T__9);
			this.state = 421;
			this.match(CertusParser.T__0);
			this.state = 422;
			this.match(CertusParser.FLOAT);
			this.state = 423;
			this.match(CertusParser.ARG_SEP);
			this.state = 424;
			this.match(CertusParser.FLOAT);
			this.state = 425;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setConst(): SetConstContext {
		let _localctx: SetConstContext = new SetConstContext(this._ctx, this.state);
		this.enterRule(_localctx, 60, CertusParser.RULE_setConst);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 427;
			this.match(CertusParser.T__10);
			this.state = 428;
			this.match(CertusParser.T__0);
			this.state = 429;
			this.match(CertusParser.FLOAT);
			this.state = 430;
			this.match(CertusParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setCrisp(): SetCrispContext {
		let _localctx: SetCrispContext = new SetCrispContext(this._ctx, this.state);
		this.enterRule(_localctx, 62, CertusParser.RULE_setCrisp);
		try {
			this.state = 443;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CertusParser.T__11:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 432;
				this.match(CertusParser.T__11);
				this.state = 433;
				this.match(CertusParser.FLOAT);
				this.state = 434;
				this.match(CertusParser.ARG_SEP);
				this.state = 435;
				this.match(CertusParser.FLOAT);
				this.state = 436;
				this.match(CertusParser.T__12);
				}
				break;
			case CertusParser.T__13:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 437;
				this.match(CertusParser.T__13);
				this.state = 438;
				this.match(CertusParser.T__0);
				this.state = 439;
				this.match(CertusParser.FLOAT);
				this.state = 440;
				this.match(CertusParser.ARG_SEP);
				this.state = 441;
				this.match(CertusParser.FLOAT);
				this.state = 442;
				this.match(CertusParser.T__1);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
		switch (ruleIndex) {
		case 8:
			return this.booleanExpr_sempred(_localctx as BooleanExprContext, predIndex);

		case 17:
			return this.fuzzyExpr_sempred(_localctx as FuzzyExprContext, predIndex);
		}
		return true;
	}
	private booleanExpr_sempred(_localctx: BooleanExprContext, predIndex: number): boolean {
		switch (predIndex) {
		case 0:
			return this.precpred(this._ctx, 12);

		case 1:
			return this.precpred(this._ctx, 11);
		}
		return true;
	}
	private fuzzyExpr_sempred(_localctx: FuzzyExprContext, predIndex: number): boolean {
		switch (predIndex) {
		case 2:
			return this.precpred(this._ctx, 7);

		case 3:
			return this.precpred(this._ctx, 6);
		}
		return true;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x031\u01C0\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
		"\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
		"\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17\x04" +
		"\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C\x04" +
		"\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x03\x02\x03\x02" +
		"\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x05\x02" +
		"M\n\x02\x03\x03\x03\x03\x03\x03\x03\x03\x07\x03S\n\x03\f\x03\x0E\x03V" +
		"\v\x03\x03\x03\x05\x03Y\n\x03\x03\x03\x03\x03\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x07\x04a\n\x04\f\x04\x0E\x04d\v\x04\x03\x04\x05\x04g\n\x04\x03" +
		"\x04\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x05\x05q" +
		"\n\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x05\x06" +
		"z\n\x06\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x07\x07\x81\n\x07\f\x07" +
		"\x0E\x07\x84\v\x07\x03\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x03\t\x03\t" +
		"\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03" +
		"\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03" +
		"\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03" +
		"\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03" +
		"\n\x03\n\x05\n\xBF\n\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x07\n\xC7\n" +
		"\n\f\n\x0E\n\xCA\v\n\x03\v\x03\v\x03\v\x03\v\x05\v\xD0\n\v\x06\v\xD2\n" +
		"\v\r\v\x0E\v\xD3\x03\v\x03\v\x03\v\x05\v\xD9\n\v\x03\f\x03\f\x03\r\x03" +
		"\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03" +
		"\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03" +
		"\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03" +
		"\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03" +
		"\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x05\r\u0115\n\r\x03\x0E\x03\x0E" +
		"\x03\x0E\x03\x0E\x05\x0E\u011B\n\x0E\x06\x0E\u011D\n\x0E\r\x0E\x0E\x0E" +
		"\u011E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\u0124\n\x0E\x03\x0F\x03\x0F\x03" +
		"\x0F\x03\x10\x03\x10\x03\x10\x03\x10\x06\x10\u012D\n\x10\r\x10\x0E\x10" +
		"\u012E\x03\x10\x03\x10\x03\x10\x03\x11\x03\x11\x03\x11\x03\x11\x03\x12" +
		"\x03\x12\x03\x12\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x05\x13" +
		"\u0141\n\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x07\x13\u0149" +
		"\n\x13\f\x13\x0E\x13\u014C\v\x13\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14" +
		"\x07\x14\u0153\n\x14\f\x14\x0E\x14\u0156\v\x14\x03\x14\x03\x14\x03\x15" +
		"\x03\x15\x03\x16\x03\x16\x03\x16\x03\x16\x05\x16\u0160\n\x16\x03\x17\x03" +
		"\x17\x03\x17\x03\x17\x03\x17\x07\x17\u0167\n\x17\f\x17\x0E\x17\u016A\v" +
		"\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18\x07\x18\u0173" +
		"\n\x18\f\x18\x0E\x18\u0176\v\x18\x03\x18\x03\x18\x03\x19\x03\x19\x03\x19" +
		"\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B" +
		"\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u018A\n\x1B\x03\x1C\x03\x1C\x03" +
		"\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03" +
		"\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03" +
		"\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1F\x03\x1F\x03" +
		"\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03 \x03 \x03 \x03 \x03 \x03!\x03" +
		"!\x03!\x03!\x03!\x03!\x03!\x03!\x03!\x03!\x03!\x05!\u01BE\n!\x03!\x02" +
		"\x02\x04\x12$\"\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10" +
		"\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 \x02\"\x02" +
		"$\x02&\x02(\x02*\x02,\x02.\x020\x022\x024\x026\x028\x02:\x02<\x02>\x02" +
		"@\x02\x02\x03\x04\x02\x16\x16##\x02\u01DD\x02L\x03\x02\x02\x02\x04N\x03" +
		"\x02\x02\x02\x06\\\x03\x02\x02\x02\bp\x03\x02\x02\x02\ny\x03\x02\x02\x02" +
		"\f{\x03\x02\x02\x02\x0E\x87\x03\x02\x02\x02\x10\x8B\x03\x02\x02\x02\x12" +
		"\xBE\x03\x02\x02\x02\x14\xD8\x03\x02\x02\x02\x16\xDA\x03\x02\x02\x02\x18" +
		"\u0114\x03\x02\x02\x02\x1A\u0123\x03\x02\x02\x02\x1C\u0125\x03\x02\x02" +
		"\x02\x1E\u0128\x03\x02\x02\x02 \u0133\x03\x02\x02\x02\"\u0137\x03\x02" +
		"\x02\x02$\u0140\x03\x02\x02\x02&\u014D\x03\x02\x02\x02(\u0159\x03\x02" +
		"\x02\x02*\u015F\x03\x02\x02\x02,\u0161\x03\x02\x02\x02.\u016D\x03\x02" +
		"\x02\x020\u0179\x03\x02\x02\x022\u017E\x03\x02\x02\x024\u0189\x03\x02" +
		"\x02\x026\u018B\x03\x02\x02\x028\u0196\x03\x02\x02\x02:\u019F\x03\x02" +
		"\x02\x02<\u01A6\x03\x02\x02\x02>\u01AD\x03\x02\x02\x02@\u01BD\x03\x02" +
		"\x02\x02BC\x05\x06\x04\x02CD\x07\x02\x02\x03DM\x03\x02\x02\x02EF\x05\x04" +
		"\x03\x02FG\x05\b\x05\x02GH\x07\x02\x02\x03HM\x03\x02\x02\x02IJ\x05\b\x05" +
		"\x02JK\x07\x02\x02\x03KM\x03\x02\x02\x02LB\x03\x02\x02\x02LE\x03\x02\x02" +
		"\x02LI\x03\x02\x02\x02M\x03\x03\x02\x02\x02NO\x07\x19\x02\x02OT\x05\n" +
		"\x06\x02PQ\x07/\x02\x02QS\x05\n\x06\x02RP\x03\x02\x02\x02SV\x03\x02\x02" +
		"\x02TR\x03\x02\x02\x02TU\x03\x02\x02\x02UX\x03\x02\x02\x02VT\x03\x02\x02" +
		"\x02WY\x07/\x02\x02XW\x03\x02\x02\x02XY\x03\x02\x02\x02YZ\x03\x02\x02" +
		"\x02Z[\x07\x1B\x02\x02[\x05\x03\x02\x02\x02\\]\x07\x1A\x02\x02]b\x05\n" +
		"\x06\x02^_\x07/\x02\x02_a\x05\n\x06\x02`^\x03\x02\x02\x02ad\x03\x02\x02" +
		"\x02b`\x03\x02\x02\x02bc\x03\x02\x02\x02cf\x03\x02\x02\x02db\x03\x02\x02" +
		"\x02eg\x07/\x02\x02fe\x03\x02\x02\x02fg\x03\x02\x02\x02gh\x03\x02\x02" +
		"\x02hi\x07\x1B\x02\x02i\x07\x03\x02\x02\x02jk\x070\x02\x02kl\x07\x12\x02" +
		"\x02lq\x05$\x13\x02mn\x070\x02\x02no\x07\x12\x02\x02oq\x05\"\x12\x02p" +
		"j\x03\x02\x02\x02pm\x03\x02\x02\x02q\t\x03\x02\x02\x02rs\x070\x02\x02" +
		"st\x07\x1C\x02\x02tz\x05$\x13\x02uv\x05\f\x07\x02vw\x07\x1C\x02\x02wx" +
		"\x05$\x13\x02xz\x03\x02\x02\x02yr\x03\x02\x02\x02yu\x03\x02\x02\x02z\v" +
		"\x03\x02\x02\x02{|\x070\x02\x02|}\x07\x03\x02\x02}\x82\x05\x0E\b\x02~" +
		"\x7F\x07.\x02\x02\x7F\x81\x05\x0E\b\x02\x80~\x03\x02\x02\x02\x81\x84\x03" +
		"\x02\x02\x02\x82\x80\x03\x02\x02\x02\x82\x83\x03\x02\x02\x02\x83\x85\x03" +
		"\x02\x02\x02\x84\x82\x03\x02\x02\x02\x85\x86\x07\x04\x02\x02\x86\r\x03" +
		"\x02\x02\x02\x87\x88\x070\x02\x02\x88\x89\x07\x05\x02\x02\x89\x8A\x05" +
		"\x10\t\x02\x8A\x0F\x03\x02\x02\x02\x8B\x8C\x070\x02\x02\x8C\x11\x03\x02" +
		"\x02\x02\x8D\x8E\b\n\x01\x02\x8E\x8F\x07\x03\x02\x02\x8F\x90\x05\x12\n" +
		"\x02\x90\x91\x07\x04\x02\x02\x91\xBF\x03\x02\x02\x02\x92\xBF\x05\x18\r" +
		"\x02\x93\xBF\x05\x1C\x0F\x02\x94\x95\x07\x1D\x02\x02\x95\xBF\x05\x12\n" +
		"\x0F\x96\x97\x05$\x13\x02\x97\x98\x07%\x02\x02\x98\x99\x05$\x13\x02\x99" +
		"\xBF\x03\x02\x02\x02\x9A\x9B\x05$\x13\x02\x9B\x9C\x07\'\x02\x02\x9C\x9D" +
		"\x05$\x13\x02\x9D\xBF\x03\x02\x02\x02\x9E\x9F\x05$\x13\x02\x9F\xA0\x07" +
		"$\x02\x02\xA0\xA1\x05$\x13\x02\xA1\xBF\x03\x02\x02\x02\xA2\xA3\x05$\x13" +
		"\x02\xA3\xA4\x07&\x02\x02\xA4\xA5\x05$\x13\x02\xA5\xBF\x03\x02\x02\x02" +
		"\xA6\xA7\x05$\x13\x02\xA7\xA8\x07#\x02\x02\xA8\xA9\x05$\x13\x02\xA9\xBF" +
		"\x03\x02\x02\x02\xAA\xAB\x05$\x13\x02\xAB\xAC\x07\"\x02\x02\xAC\xAD\x05" +
		"$\x13\x02\xAD\xBF\x03\x02\x02\x02\xAE\xAF\x05$\x13\x02\xAF\xB0\x07\x16" +
		"\x02\x02\xB0\xB1\x05$\x13\x02\xB1\xBF\x03\x02\x02\x02\xB2\xB3\x05$\x13" +
		"\x02\xB3\xB4\x07\x12\x02\x02\xB4\xB5\x05$\x13\x02\xB5\xBF\x03\x02\x02" +
		"\x02\xB6\xB7\x05$\x13\x02\xB7\xB8\x07\x14\x02\x02\xB8\xB9\x05$\x13\x02" +
		"\xB9\xBF\x03\x02\x02\x02\xBA\xBB\x05$\x13\x02\xBB\xBC\x07\x15\x02\x02" +
		"\xBC\xBD\x05$\x13\x02\xBD\xBF\x03\x02\x02\x02\xBE\x8D\x03\x02\x02\x02" +
		"\xBE\x92\x03\x02\x02\x02\xBE\x93\x03\x02\x02\x02\xBE\x94\x03\x02\x02\x02" +
		"\xBE\x96\x03\x02\x02\x02\xBE\x9A\x03\x02\x02\x02\xBE\x9E\x03\x02\x02\x02" +
		"\xBE\xA2\x03\x02\x02\x02\xBE\xA6\x03\x02\x02\x02\xBE\xAA\x03\x02\x02\x02" +
		"\xBE\xAE\x03\x02\x02\x02\xBE\xB2\x03\x02\x02\x02\xBE\xB6\x03\x02\x02\x02" +
		"\xBE\xBA\x03\x02\x02\x02\xBF\xC8\x03\x02\x02\x02\xC0\xC1\f\x0E\x02\x02" +
		"\xC1\xC2\x07 \x02\x02\xC2\xC7\x05\x12\n\x0F\xC3\xC4\f\r\x02\x02\xC4\xC5" +
		"\x07!\x02\x02\xC5\xC7\x05\x12\n\x0E\xC6\xC0\x03\x02\x02\x02\xC6\xC3\x03" +
		"\x02\x02\x02\xC7\xCA\x03\x02\x02\x02\xC8\xC6\x03\x02\x02\x02\xC8\xC9\x03" +
		"\x02\x02\x02\xC9\x13\x03\x02\x02\x02\xCA\xC8\x03\x02\x02\x02\xCB\xCC\x07" +
		")\x02\x02\xCC\xD1\x07\x06\x02\x02\xCD\xCF\x070\x02\x02\xCE\xD0\x071\x02" +
		"\x02\xCF\xCE\x03\x02\x02\x02\xCF\xD0\x03\x02\x02\x02\xD0\xD2\x03\x02\x02" +
		"\x02\xD1\xCD\x03\x02\x02\x02\xD2\xD3\x03\x02\x02\x02\xD3\xD1\x03\x02\x02" +
		"\x02\xD3\xD4\x03\x02\x02\x02\xD4\xD5\x03\x02\x02\x02\xD5\xD9\x07\x06\x02" +
		"\x02\xD6\xD7\x07)\x02\x02\xD7\xD9\x070\x02\x02\xD8\xCB\x03\x02\x02\x02" +
		"\xD8\xD6\x03\x02\x02\x02\xD9\x15\x03\x02\x02\x02\xDA\xDB\x070\x02\x02" +
		"\xDB\x17\x03\x02\x02\x02\xDC\xDD\x05\x14\v\x02\xDD\xDE\x07\x12\x02\x02" +
		"\xDE\xDF\x05\x16\f\x02\xDF\u0115\x03\x02\x02\x02\xE0\xE1\x05\x14\v\x02" +
		"\xE1\xE2\t\x02\x02\x02\xE2\xE3\x05\x14\v\x02\xE3\u0115\x03\x02\x02\x02" +
		"\xE4\xE5\x05\x14\v\x02\xE5\xE6\x07%\x02\x02\xE6\xE7\x05\x14\v\x02\xE7" +
		"\u0115\x03\x02\x02\x02\xE8\xE9\x05\x14\v\x02\xE9\xEA\x07\'\x02\x02\xEA" +
		"\xEB\x05\x14\v\x02\xEB\u0115\x03\x02\x02\x02\xEC\xED\x05\x14\v\x02\xED" +
		"\xEE\x07$\x02\x02\xEE\xEF\x05\x14\v\x02\xEF\u0115\x03\x02\x02\x02\xF0" +
		"\xF1\x05\x14\v\x02\xF1\xF2\x07&\x02\x02\xF2\xF3\x05\x14\v\x02\xF3\u0115" +
		"\x03\x02\x02\x02\xF4\xF5\x05\x14\v\x02\xF5\xF6\x07\"\x02\x02\xF6\xF7\x05" +
		"\x14\v\x02\xF7\u0115\x03\x02\x02\x02\xF8\xF9\x05\x14\v\x02\xF9\xFA\x07" +
		"%\x02\x02\xFA\xFB\x05\x14\v\x02\xFB\u0115\x03\x02\x02\x02\xFC\xFD\x05" +
		"\x14\v\x02\xFD\xFE\t\x02\x02\x02\xFE\xFF\x07-\x02\x02\xFF\u0115\x03\x02" +
		"\x02\x02\u0100\u0101\x05\x14\v\x02\u0101\u0102\x07%\x02\x02\u0102\u0103" +
		"\x07-\x02\x02\u0103\u0115\x03\x02\x02\x02\u0104\u0105\x05\x14\v\x02\u0105" +
		"\u0106\x07\'\x02\x02\u0106\u0107\x07-\x02\x02\u0107\u0115\x03\x02\x02" +
		"\x02\u0108\u0109\x05\x14\v\x02\u0109\u010A\x07$\x02\x02\u010A\u010B\x07" +
		"-\x02\x02\u010B\u0115\x03\x02\x02\x02\u010C\u010D\x05\x14\v\x02\u010D" +
		"\u010E\x07&\x02\x02\u010E\u010F\x07-\x02\x02\u010F\u0115\x03\x02\x02\x02" +
		"\u0110\u0111\x05\x14\v\x02\u0111\u0112\x07\"\x02\x02\u0112\u0113\x07-" +
		"\x02\x02\u0113\u0115\x03\x02\x02\x02\u0114\xDC\x03\x02\x02\x02\u0114\xE0" +
		"\x03\x02\x02\x02\u0114\xE4\x03\x02\x02\x02\u0114\xE8\x03\x02\x02\x02\u0114" +
		"\xEC\x03\x02\x02\x02\u0114\xF0\x03\x02\x02\x02\u0114\xF4\x03\x02\x02\x02" +
		"\u0114\xF8\x03\x02\x02\x02\u0114\xFC\x03\x02\x02\x02\u0114\u0100\x03\x02" +
		"\x02\x02\u0114\u0104\x03\x02\x02\x02\u0114\u0108\x03\x02\x02\x02\u0114" +
		"\u010C\x03\x02\x02\x02\u0114\u0110\x03\x02\x02\x02\u0115\x19\x03\x02\x02" +
		"\x02\u0116\u0117\x07*\x02\x02\u0117\u011C\x07\x06\x02\x02\u0118\u011A" +
		"\x070\x02\x02\u0119\u011B\x071\x02\x02\u011A\u0119\x03\x02\x02\x02\u011A" +
		"\u011B\x03\x02\x02\x02\u011B\u011D\x03\x02\x02\x02\u011C\u0118\x03\x02" +
		"\x02\x02\u011D\u011E\x03\x02\x02\x02\u011E\u011C\x03\x02\x02\x02\u011E" +
		"\u011F\x03\x02\x02\x02\u011F\u0120\x03\x02\x02\x02\u0120\u0124\x07\x06" +
		"\x02\x02\u0121\u0122\x07*\x02\x02\u0122\u0124\x070\x02\x02\u0123\u0116" +
		"\x03\x02\x02\x02\u0123\u0121\x03\x02\x02\x02\u0124\x1B\x03\x02\x02\x02" +
		"\u0125\u0126\x07\x13\x02\x02\u0126\u0127\x05\x1A\x0E\x02\u0127\x1D\x03" +
		"\x02\x02\x02\u0128\u012C\x07+\x02\x02\u0129\u012A\x05 \x11\x02\u012A\u012B" +
		"\x07.\x02\x02\u012B\u012D\x03\x02\x02\x02\u012C\u0129\x03\x02\x02\x02" +
		"\u012D\u012E\x03\x02\x02\x02\u012E\u012C\x03\x02\x02\x02\u012E\u012F\x03" +
		"\x02\x02\x02\u012F\u0130\x03\x02\x02\x02\u0130\u0131\x07,\x02\x02\u0131" +
		"\u0132\x05$\x13\x02\u0132\x1F\x03\x02\x02\x02\u0133\u0134\x05\x12\n\x02" +
		"\u0134\u0135\x07\x11\x02\x02\u0135\u0136\x05$\x13\x02\u0136!\x03\x02\x02" +
		"\x02\u0137\u0138\x07(\x02\x02\u0138\u0139\x070\x02\x02\u0139#\x03\x02" +
		"\x02\x02\u013A\u013B\b\x13\x01\x02\u013B\u0141\x05\x1E\x10\x02\u013C\u0141" +
		"\x054\x1B\x02\u013D\u0141\x05*\x16\x02\u013E\u0141\x05&\x14\x02\u013F" +
		"\u0141\x05(\x15\x02\u0140\u013A\x03\x02\x02\x02\u0140\u013C\x03\x02\x02" +
		"\x02\u0140\u013D\x03\x02\x02\x02\u0140\u013E\x03\x02\x02\x02\u0140\u013F" +
		"\x03\x02\x02\x02\u0141\u014A\x03\x02\x02\x02\u0142\u0143\f\t\x02\x02\u0143" +
		"\u0144\x07\x18\x02\x02\u0144\u0149\x05$\x13\n\u0145\u0146\f\b\x02\x02" +
		"\u0146\u0147\x07\x17\x02\x02\u0147\u0149\x05$\x13\t\u0148\u0142\x03\x02" +
		"\x02\x02\u0148\u0145\x03\x02\x02\x02\u0149\u014C\x03\x02\x02\x02\u014A" +
		"\u0148\x03\x02\x02\x02\u014A\u014B\x03\x02\x02\x02\u014B%\x03\x02\x02" +
		"\x02\u014C\u014A\x03\x02\x02\x02\u014D\u014E\x070\x02\x02\u014E\u014F" +
		"\x07\x03\x02\x02\u014F\u0154\x070\x02\x02\u0150\u0151\x07.\x02\x02\u0151" +
		"\u0153\x070\x02\x02\u0152\u0150\x03\x02\x02\x02\u0153\u0156\x03\x02\x02" +
		"\x02\u0154\u0152\x03\x02\x02\x02\u0154\u0155\x03\x02\x02\x02\u0155\u0157" +
		"\x03\x02\x02\x02\u0156\u0154\x03\x02\x02\x02\u0157\u0158\x07\x04\x02\x02" +
		"\u0158\'\x03\x02\x02\x02\u0159\u015A\x070\x02\x02\u015A)\x03\x02\x02\x02" +
		"\u015B\u0160\x05,\x17\x02\u015C\u0160\x05.\x18\x02\u015D\u0160\x050\x19" +
		"\x02\u015E\u0160\x052\x1A\x02\u015F\u015B\x03\x02\x02\x02\u015F\u015C" +
		"\x03\x02\x02\x02\u015F\u015D\x03\x02\x02\x02\u015F\u015E\x03\x02\x02\x02" +
		"\u0160+\x03\x02\x02\x02\u0161\u0162\x07\x07\x02\x02\u0162\u0163\x07\x03" +
		"\x02\x02\u0163\u0168\x05$\x13\x02\u0164\u0165\x07.\x02\x02\u0165\u0167" +
		"\x05$\x13\x02\u0166\u0164\x03\x02\x02\x02\u0167\u016A\x03\x02\x02\x02" +
		"\u0168\u0166\x03\x02\x02\x02\u0168\u0169\x03\x02\x02\x02\u0169\u016B\x03" +
		"\x02\x02\x02\u016A\u0168\x03\x02\x02\x02\u016B\u016C\x07\x04\x02\x02\u016C" +
		"-\x03\x02\x02\x02\u016D\u016E\x07\b\x02\x02\u016E\u016F\x07\x03\x02\x02" +
		"\u016F\u0174\x05$\x13\x02\u0170\u0171\x07.\x02\x02\u0171\u0173\x05$\x13" +
		"\x02\u0172\u0170\x03\x02\x02\x02\u0173\u0176\x03\x02\x02\x02\u0174\u0172" +
		"\x03\x02\x02\x02\u0174\u0175\x03\x02\x02\x02\u0175\u0177\x03\x02\x02\x02" +
		"\u0176\u0174\x03\x02\x02\x02\u0177\u0178\x07\x04\x02\x02\u0178/\x03\x02" +
		"\x02\x02\u0179\u017A\x07\x1E\x02\x02\u017A\u017B\x07\x03\x02\x02\u017B" +
		"\u017C\x05$\x13\x02\u017C\u017D\x07\x04\x02\x02\u017D1\x03\x02\x02\x02" +
		"\u017E\u017F\x07\x1F\x02\x02\u017F\u0180\x07\x03\x02\x02\u0180\u0181\x05" +
		"$\x13\x02\u0181\u0182\x07\x04\x02\x02\u01823\x03\x02\x02\x02\u0183\u018A" +
		"\x056\x1C\x02\u0184\u018A\x058\x1D\x02\u0185\u018A\x05:\x1E\x02\u0186" +
		"\u018A\x05<\x1F\x02\u0187\u018A\x05> \x02\u0188\u018A\x05@!\x02\u0189" +
		"\u0183\x03\x02\x02\x02\u0189\u0184\x03\x02\x02\x02\u0189\u0185\x03\x02" +
		"\x02\x02\u0189\u0186\x03\x02\x02\x02\u0189\u0187\x03\x02\x02\x02\u0189" +
		"\u0188\x03\x02\x02\x02\u018A5\x03\x02\x02\x02\u018B\u018C\x07\t\x02\x02" +
		"\u018C\u018D\x07\x03\x02\x02\u018D\u018E\x07-\x02\x02\u018E\u018F\x07" +
		".\x02\x02\u018F\u0190\x07-\x02\x02\u0190\u0191\x07.\x02\x02\u0191\u0192" +
		"\x07-\x02\x02\u0192\u0193\x07.\x02\x02\u0193\u0194\x07-\x02\x02\u0194" +
		"\u0195\x07\x04\x02\x02\u01957\x03\x02\x02\x02\u0196\u0197\x07\n\x02\x02" +
		"\u0197\u0198\x07\x03\x02\x02\u0198\u0199\x07-\x02\x02\u0199\u019A\x07" +
		".\x02\x02\u019A\u019B\x07-\x02\x02\u019B\u019C\x07.\x02\x02\u019C\u019D" +
		"\x07-\x02\x02\u019D\u019E\x07\x04\x02\x02\u019E9\x03\x02\x02\x02\u019F" +
		"\u01A0\x07\v\x02\x02\u01A0\u01A1\x07\x03\x02\x02\u01A1\u01A2\x07-\x02" +
		"\x02\u01A2\u01A3\x07.\x02\x02\u01A3\u01A4\x07-\x02\x02\u01A4\u01A5\x07" +
		"\x04\x02\x02\u01A5;\x03\x02\x02\x02\u01A6\u01A7\x07\f\x02\x02\u01A7\u01A8" +
		"\x07\x03\x02\x02\u01A8\u01A9\x07-\x02\x02\u01A9\u01AA\x07.\x02\x02\u01AA" +
		"\u01AB\x07-\x02\x02\u01AB\u01AC\x07\x04\x02\x02\u01AC=\x03\x02\x02\x02" +
		"\u01AD\u01AE\x07\r\x02\x02\u01AE\u01AF\x07\x03\x02\x02\u01AF\u01B0\x07" +
		"-\x02\x02\u01B0\u01B1\x07\x04\x02\x02\u01B1?\x03\x02\x02\x02\u01B2\u01B3" +
		"\x07\x0E\x02\x02\u01B3\u01B4\x07-\x02\x02\u01B4\u01B5\x07.\x02\x02\u01B5" +
		"\u01B6\x07-\x02\x02\u01B6\u01BE\x07\x0F\x02\x02\u01B7\u01B8\x07\x10\x02" +
		"\x02\u01B8\u01B9\x07\x03\x02\x02\u01B9\u01BA\x07-\x02\x02\u01BA\u01BB" +
		"\x07.\x02\x02\u01BB\u01BC\x07-\x02\x02\u01BC\u01BE\x07\x04\x02\x02\u01BD" +
		"\u01B2\x03\x02\x02\x02\u01BD\u01B7\x03\x02\x02\x02\u01BEA\x03\x02\x02" +
		"\x02\x1ELTXbfpy\x82\xBE\xC6\xC8\xCF\xD3\xD8\u0114\u011A\u011E\u0123\u012E" +
		"\u0140\u0148\u014A\u0154\u015F\u0168\u0174\u0189\u01BD";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!CertusParser.__ATN) {
			CertusParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(CertusParser._serializedATN));
		}

		return CertusParser.__ATN;
	}

}

export class StartContext extends ParserRuleContext {
	public globalBind(): GlobalBindContext | undefined {
		return this.tryGetRuleContext(0, GlobalBindContext);
	}
	public EOF(): TerminalNode { return this.getToken(CertusParser.EOF, 0); }
	public localBind(): LocalBindContext | undefined {
		return this.tryGetRuleContext(0, LocalBindContext);
	}
	public assignment(): AssignmentContext | undefined {
		return this.tryGetRuleContext(0, AssignmentContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_start; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterStart) {
			listener.enterStart(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitStart) {
			listener.exitStart(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitStart) {
			return visitor.visitStart(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class LocalBindContext extends ParserRuleContext {
	public WITH(): TerminalNode { return this.getToken(CertusParser.WITH, 0); }
	public definition(): DefinitionContext[];
	public definition(i: number): DefinitionContext;
	public definition(i?: number): DefinitionContext | DefinitionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(DefinitionContext);
		} else {
			return this.getRuleContext(i, DefinitionContext);
		}
	}
	public END(): TerminalNode { return this.getToken(CertusParser.END, 0); }
	public STMT_SEP(): TerminalNode[];
	public STMT_SEP(i: number): TerminalNode;
	public STMT_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.STMT_SEP);
		} else {
			return this.getToken(CertusParser.STMT_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_localBind; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterLocalBind) {
			listener.enterLocalBind(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitLocalBind) {
			listener.exitLocalBind(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitLocalBind) {
			return visitor.visitLocalBind(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class GlobalBindContext extends ParserRuleContext {
	public GLOBAL(): TerminalNode { return this.getToken(CertusParser.GLOBAL, 0); }
	public definition(): DefinitionContext[];
	public definition(i: number): DefinitionContext;
	public definition(i?: number): DefinitionContext | DefinitionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(DefinitionContext);
		} else {
			return this.getRuleContext(i, DefinitionContext);
		}
	}
	public END(): TerminalNode { return this.getToken(CertusParser.END, 0); }
	public STMT_SEP(): TerminalNode[];
	public STMT_SEP(i: number): TerminalNode;
	public STMT_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.STMT_SEP);
		} else {
			return this.getToken(CertusParser.STMT_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_globalBind; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterGlobalBind) {
			listener.enterGlobalBind(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitGlobalBind) {
			listener.exitGlobalBind(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitGlobalBind) {
			return visitor.visitGlobalBind(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AssignmentContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	public ASSIGN(): TerminalNode { return this.getToken(CertusParser.ASSIGN, 0); }
	public fuzzyExpr(): FuzzyExprContext | undefined {
		return this.tryGetRuleContext(0, FuzzyExprContext);
	}
	public macroExpr(): MacroExprContext | undefined {
		return this.tryGetRuleContext(0, MacroExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_assignment; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterAssignment) {
			listener.enterAssignment(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitAssignment) {
			listener.exitAssignment(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitAssignment) {
			return visitor.visitAssignment(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DefinitionContext extends ParserRuleContext {
	public ID(): TerminalNode | undefined { return this.tryGetToken(CertusParser.ID, 0); }
	public AS(): TerminalNode { return this.getToken(CertusParser.AS, 0); }
	public fuzzyExpr(): FuzzyExprContext {
		return this.getRuleContext(0, FuzzyExprContext);
	}
	public opDef(): OpDefContext | undefined {
		return this.tryGetRuleContext(0, OpDefContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_definition; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterDefinition) {
			listener.enterDefinition(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitDefinition) {
			listener.exitDefinition(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitDefinition) {
			return visitor.visitDefinition(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class OpDefContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	public opTypedParam(): OpTypedParamContext[];
	public opTypedParam(i: number): OpTypedParamContext;
	public opTypedParam(i?: number): OpTypedParamContext | OpTypedParamContext[] {
		if (i === undefined) {
			return this.getRuleContexts(OpTypedParamContext);
		} else {
			return this.getRuleContext(i, OpTypedParamContext);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_opDef; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterOpDef) {
			listener.enterOpDef(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitOpDef) {
			listener.exitOpDef(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitOpDef) {
			return visitor.visitOpDef(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class OpTypedParamContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	public nodeType(): NodeTypeContext {
		return this.getRuleContext(0, NodeTypeContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_opTypedParam; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterOpTypedParam) {
			listener.enterOpTypedParam(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitOpTypedParam) {
			listener.exitOpTypedParam(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitOpTypedParam) {
			return visitor.visitOpTypedParam(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NodeTypeContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_nodeType; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterNodeType) {
			listener.enterNodeType(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitNodeType) {
			listener.exitNodeType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitNodeType) {
			return visitor.visitNodeType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BooleanExprContext extends ParserRuleContext {
	public booleanExpr(): BooleanExprContext[];
	public booleanExpr(i: number): BooleanExprContext;
	public booleanExpr(i?: number): BooleanExprContext | BooleanExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(BooleanExprContext);
		} else {
			return this.getRuleContext(i, BooleanExprContext);
		}
	}
	public indicatorExpr(): IndicatorExprContext | undefined {
		return this.tryGetRuleContext(0, IndicatorExprContext);
	}
	public artifactExpr(): ArtifactExprContext | undefined {
		return this.tryGetRuleContext(0, ArtifactExprContext);
	}
	public NOT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.NOT, 0); }
	public AND(): TerminalNode | undefined { return this.tryGetToken(CertusParser.AND, 0); }
	public OR(): TerminalNode | undefined { return this.tryGetToken(CertusParser.OR, 0); }
	public fuzzyExpr(): FuzzyExprContext[];
	public fuzzyExpr(i: number): FuzzyExprContext;
	public fuzzyExpr(i?: number): FuzzyExprContext | FuzzyExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FuzzyExprContext);
		} else {
			return this.getRuleContext(i, FuzzyExprContext);
		}
	}
	public LT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.LT, 0); }
	public LEQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.LEQ, 0); }
	public GT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.GT, 0); }
	public GEQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.GEQ, 0); }
	public EQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.EQ, 0); }
	public NEQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.NEQ, 0); }
	public EXACTLY(): TerminalNode | undefined { return this.tryGetToken(CertusParser.EXACTLY, 0); }
	public ASSIGN(): TerminalNode | undefined { return this.tryGetToken(CertusParser.ASSIGN, 0); }
	public CONTAIN(): TerminalNode | undefined { return this.tryGetToken(CertusParser.CONTAIN, 0); }
	public OVERLAP(): TerminalNode | undefined { return this.tryGetToken(CertusParser.OVERLAP, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_booleanExpr; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterBooleanExpr) {
			listener.enterBooleanExpr(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitBooleanExpr) {
			listener.exitBooleanExpr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitBooleanExpr) {
			return visitor.visitBooleanExpr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IndicatorContext extends ParserRuleContext {
	public INDICATOR_PREFIX(): TerminalNode { return this.getToken(CertusParser.INDICATOR_PREFIX, 0); }
	public ID(): TerminalNode[];
	public ID(i: number): TerminalNode;
	public ID(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ID);
		} else {
			return this.getToken(CertusParser.ID, i);
		}
	}
	public WS(): TerminalNode[];
	public WS(i: number): TerminalNode;
	public WS(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.WS);
		} else {
			return this.getToken(CertusParser.WS, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_indicator; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterIndicator) {
			listener.enterIndicator(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitIndicator) {
			listener.exitIndicator(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitIndicator) {
			return visitor.visitIndicator(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IndicatorCategoryContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_indicatorCategory; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterIndicatorCategory) {
			listener.enterIndicatorCategory(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitIndicatorCategory) {
			listener.exitIndicatorCategory(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitIndicatorCategory) {
			return visitor.visitIndicatorCategory(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IndicatorExprContext extends ParserRuleContext {
	public indicator(): IndicatorContext[];
	public indicator(i: number): IndicatorContext;
	public indicator(i?: number): IndicatorContext | IndicatorContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IndicatorContext);
		} else {
			return this.getRuleContext(i, IndicatorContext);
		}
	}
	public ASSIGN(): TerminalNode | undefined { return this.tryGetToken(CertusParser.ASSIGN, 0); }
	public indicatorCategory(): IndicatorCategoryContext | undefined {
		return this.tryGetRuleContext(0, IndicatorCategoryContext);
	}
	public EQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.EQ, 0); }
	public EXACTLY(): TerminalNode | undefined { return this.tryGetToken(CertusParser.EXACTLY, 0); }
	public LT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.LT, 0); }
	public LEQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.LEQ, 0); }
	public GT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.GT, 0); }
	public GEQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.GEQ, 0); }
	public NEQ(): TerminalNode | undefined { return this.tryGetToken(CertusParser.NEQ, 0); }
	public FLOAT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.FLOAT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_indicatorExpr; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterIndicatorExpr) {
			listener.enterIndicatorExpr(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitIndicatorExpr) {
			listener.exitIndicatorExpr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitIndicatorExpr) {
			return visitor.visitIndicatorExpr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ArtifactContext extends ParserRuleContext {
	public ARTIFACT_PREFIX(): TerminalNode { return this.getToken(CertusParser.ARTIFACT_PREFIX, 0); }
	public ID(): TerminalNode[];
	public ID(i: number): TerminalNode;
	public ID(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ID);
		} else {
			return this.getToken(CertusParser.ID, i);
		}
	}
	public WS(): TerminalNode[];
	public WS(i: number): TerminalNode;
	public WS(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.WS);
		} else {
			return this.getToken(CertusParser.WS, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_artifact; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterArtifact) {
			listener.enterArtifact(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitArtifact) {
			listener.exitArtifact(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitArtifact) {
			return visitor.visitArtifact(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ArtifactExprContext extends ParserRuleContext {
	public HAS(): TerminalNode { return this.getToken(CertusParser.HAS, 0); }
	public artifact(): ArtifactContext {
		return this.getRuleContext(0, ArtifactContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_artifactExpr; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterArtifactExpr) {
			listener.enterArtifactExpr(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitArtifactExpr) {
			listener.exitArtifactExpr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitArtifactExpr) {
			return visitor.visitArtifactExpr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CasesExprContext extends ParserRuleContext {
	public CASES(): TerminalNode { return this.getToken(CertusParser.CASES, 0); }
	public OTHERWISE(): TerminalNode { return this.getToken(CertusParser.OTHERWISE, 0); }
	public fuzzyExpr(): FuzzyExprContext {
		return this.getRuleContext(0, FuzzyExprContext);
	}
	public case(): CaseContext[];
	public case(i: number): CaseContext;
	public case(i?: number): CaseContext | CaseContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CaseContext);
		} else {
			return this.getRuleContext(i, CaseContext);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_casesExpr; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterCasesExpr) {
			listener.enterCasesExpr(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitCasesExpr) {
			listener.exitCasesExpr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitCasesExpr) {
			return visitor.visitCasesExpr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CaseContext extends ParserRuleContext {
	public booleanExpr(): BooleanExprContext {
		return this.getRuleContext(0, BooleanExprContext);
	}
	public ARROW(): TerminalNode { return this.getToken(CertusParser.ARROW, 0); }
	public fuzzyExpr(): FuzzyExprContext {
		return this.getRuleContext(0, FuzzyExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_case; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterCase) {
			listener.enterCase(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitCase) {
			listener.exitCase(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitCase) {
			return visitor.visitCase(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MacroExprContext extends ParserRuleContext {
	public MACRO_PREFIX(): TerminalNode { return this.getToken(CertusParser.MACRO_PREFIX, 0); }
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_macroExpr; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterMacroExpr) {
			listener.enterMacroExpr(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitMacroExpr) {
			listener.exitMacroExpr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitMacroExpr) {
			return visitor.visitMacroExpr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FuzzyExprContext extends ParserRuleContext {
	public fuzzyExpr(): FuzzyExprContext[];
	public fuzzyExpr(i: number): FuzzyExprContext;
	public fuzzyExpr(i?: number): FuzzyExprContext | FuzzyExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FuzzyExprContext);
		} else {
			return this.getRuleContext(i, FuzzyExprContext);
		}
	}
	public INTERSECT(): TerminalNode | undefined { return this.tryGetToken(CertusParser.INTERSECT, 0); }
	public UNION(): TerminalNode | undefined { return this.tryGetToken(CertusParser.UNION, 0); }
	public casesExpr(): CasesExprContext | undefined {
		return this.tryGetRuleContext(0, CasesExprContext);
	}
	public defineSet(): DefineSetContext | undefined {
		return this.tryGetRuleContext(0, DefineSetContext);
	}
	public builtInOp(): BuiltInOpContext | undefined {
		return this.tryGetRuleContext(0, BuiltInOpContext);
	}
	public invokedOp(): InvokedOpContext | undefined {
		return this.tryGetRuleContext(0, InvokedOpContext);
	}
	public fuzzySym(): FuzzySymContext | undefined {
		return this.tryGetRuleContext(0, FuzzySymContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_fuzzyExpr; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterFuzzyExpr) {
			listener.enterFuzzyExpr(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitFuzzyExpr) {
			listener.exitFuzzyExpr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitFuzzyExpr) {
			return visitor.visitFuzzyExpr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class InvokedOpContext extends ParserRuleContext {
	public ID(): TerminalNode[];
	public ID(i: number): TerminalNode;
	public ID(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ID);
		} else {
			return this.getToken(CertusParser.ID, i);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_invokedOp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterInvokedOp) {
			listener.enterInvokedOp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitInvokedOp) {
			listener.exitInvokedOp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitInvokedOp) {
			return visitor.visitInvokedOp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FuzzySymContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CertusParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_fuzzySym; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterFuzzySym) {
			listener.enterFuzzySym(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitFuzzySym) {
			listener.exitFuzzySym(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitFuzzySym) {
			return visitor.visitFuzzySym(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BuiltInOpContext extends ParserRuleContext {
	public minOp(): MinOpContext | undefined {
		return this.tryGetRuleContext(0, MinOpContext);
	}
	public maxOp(): MaxOpContext | undefined {
		return this.tryGetRuleContext(0, MaxOpContext);
	}
	public invertOp(): InvertOpContext | undefined {
		return this.tryGetRuleContext(0, InvertOpContext);
	}
	public compOp(): CompOpContext | undefined {
		return this.tryGetRuleContext(0, CompOpContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_builtInOp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterBuiltInOp) {
			listener.enterBuiltInOp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitBuiltInOp) {
			listener.exitBuiltInOp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitBuiltInOp) {
			return visitor.visitBuiltInOp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MinOpContext extends ParserRuleContext {
	public fuzzyExpr(): FuzzyExprContext[];
	public fuzzyExpr(i: number): FuzzyExprContext;
	public fuzzyExpr(i?: number): FuzzyExprContext | FuzzyExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FuzzyExprContext);
		} else {
			return this.getRuleContext(i, FuzzyExprContext);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_minOp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterMinOp) {
			listener.enterMinOp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitMinOp) {
			listener.exitMinOp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitMinOp) {
			return visitor.visitMinOp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MaxOpContext extends ParserRuleContext {
	public fuzzyExpr(): FuzzyExprContext[];
	public fuzzyExpr(i: number): FuzzyExprContext;
	public fuzzyExpr(i?: number): FuzzyExprContext | FuzzyExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FuzzyExprContext);
		} else {
			return this.getRuleContext(i, FuzzyExprContext);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_maxOp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterMaxOp) {
			listener.enterMaxOp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitMaxOp) {
			listener.exitMaxOp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitMaxOp) {
			return visitor.visitMaxOp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class InvertOpContext extends ParserRuleContext {
	public INVERT(): TerminalNode { return this.getToken(CertusParser.INVERT, 0); }
	public fuzzyExpr(): FuzzyExprContext {
		return this.getRuleContext(0, FuzzyExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_invertOp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterInvertOp) {
			listener.enterInvertOp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitInvertOp) {
			listener.exitInvertOp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitInvertOp) {
			return visitor.visitInvertOp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CompOpContext extends ParserRuleContext {
	public COMP(): TerminalNode { return this.getToken(CertusParser.COMP, 0); }
	public fuzzyExpr(): FuzzyExprContext {
		return this.getRuleContext(0, FuzzyExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_compOp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterCompOp) {
			listener.enterCompOp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitCompOp) {
			listener.exitCompOp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitCompOp) {
			return visitor.visitCompOp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DefineSetContext extends ParserRuleContext {
	public setTrap(): SetTrapContext | undefined {
		return this.tryGetRuleContext(0, SetTrapContext);
	}
	public setTri(): SetTriContext | undefined {
		return this.tryGetRuleContext(0, SetTriContext);
	}
	public setUp(): SetUpContext | undefined {
		return this.tryGetRuleContext(0, SetUpContext);
	}
	public setDown(): SetDownContext | undefined {
		return this.tryGetRuleContext(0, SetDownContext);
	}
	public setConst(): SetConstContext | undefined {
		return this.tryGetRuleContext(0, SetConstContext);
	}
	public setCrisp(): SetCrispContext | undefined {
		return this.tryGetRuleContext(0, SetCrispContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_defineSet; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterDefineSet) {
			listener.enterDefineSet(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitDefineSet) {
			listener.exitDefineSet(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitDefineSet) {
			return visitor.visitDefineSet(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetTrapContext extends ParserRuleContext {
	public FLOAT(): TerminalNode[];
	public FLOAT(i: number): TerminalNode;
	public FLOAT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.FLOAT);
		} else {
			return this.getToken(CertusParser.FLOAT, i);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_setTrap; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterSetTrap) {
			listener.enterSetTrap(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitSetTrap) {
			listener.exitSetTrap(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitSetTrap) {
			return visitor.visitSetTrap(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetTriContext extends ParserRuleContext {
	public FLOAT(): TerminalNode[];
	public FLOAT(i: number): TerminalNode;
	public FLOAT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.FLOAT);
		} else {
			return this.getToken(CertusParser.FLOAT, i);
		}
	}
	public ARG_SEP(): TerminalNode[];
	public ARG_SEP(i: number): TerminalNode;
	public ARG_SEP(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.ARG_SEP);
		} else {
			return this.getToken(CertusParser.ARG_SEP, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_setTri; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterSetTri) {
			listener.enterSetTri(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitSetTri) {
			listener.exitSetTri(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitSetTri) {
			return visitor.visitSetTri(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetUpContext extends ParserRuleContext {
	public FLOAT(): TerminalNode[];
	public FLOAT(i: number): TerminalNode;
	public FLOAT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.FLOAT);
		} else {
			return this.getToken(CertusParser.FLOAT, i);
		}
	}
	public ARG_SEP(): TerminalNode { return this.getToken(CertusParser.ARG_SEP, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_setUp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterSetUp) {
			listener.enterSetUp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitSetUp) {
			listener.exitSetUp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitSetUp) {
			return visitor.visitSetUp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetDownContext extends ParserRuleContext {
	public FLOAT(): TerminalNode[];
	public FLOAT(i: number): TerminalNode;
	public FLOAT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.FLOAT);
		} else {
			return this.getToken(CertusParser.FLOAT, i);
		}
	}
	public ARG_SEP(): TerminalNode { return this.getToken(CertusParser.ARG_SEP, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_setDown; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterSetDown) {
			listener.enterSetDown(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitSetDown) {
			listener.exitSetDown(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitSetDown) {
			return visitor.visitSetDown(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetConstContext extends ParserRuleContext {
	public FLOAT(): TerminalNode { return this.getToken(CertusParser.FLOAT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_setConst; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterSetConst) {
			listener.enterSetConst(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitSetConst) {
			listener.exitSetConst(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitSetConst) {
			return visitor.visitSetConst(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetCrispContext extends ParserRuleContext {
	public FLOAT(): TerminalNode[];
	public FLOAT(i: number): TerminalNode;
	public FLOAT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CertusParser.FLOAT);
		} else {
			return this.getToken(CertusParser.FLOAT, i);
		}
	}
	public ARG_SEP(): TerminalNode { return this.getToken(CertusParser.ARG_SEP, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CertusParser.RULE_setCrisp; }
	// @Override
	public enterRule(listener: CertusListener): void {
		if (listener.enterSetCrisp) {
			listener.enterSetCrisp(this);
		}
	}
	// @Override
	public exitRule(listener: CertusListener): void {
		if (listener.exitSetCrisp) {
			listener.exitSetCrisp(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CertusVisitor<Result>): Result {
		if (visitor.visitSetCrisp) {
			return visitor.visitSetCrisp(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}