public final ExtElementContext extElement() throws RecognitionException {
		ExtElementContext _localctx = new ExtElementContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_extElement);
		int _la;
		try {
			setState(736);
			switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
			case 1:
				_localctx = new TypeExtensionContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(614); match(T__2);
				setState(616);
				_la = _input.LA(1);
				if (_la==T__38) {
					{
					setState(615); typeVarTuple();
					}
				}

				setState(618); match(ID);
				setState(622);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__35) {
					{
					{
					setState(619); annotation();
					}
					}
					setState(624);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(626);
				_la = _input.LA(1);
				if (_la==T__22) {
					{
					setState(625); extendClauses();
					}
				}

				setState(628); match(T__25);
				}
				break;
			case 2:
				_localctx = new ActionExtensionContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(629); match(T__43);
				setState(631);
				_la = _input.LA(1);
				if (_la==T__38) {
					{
					setState(630); typeVarTuple();
					}
				}

				setState(633); match(ID);
				setState(639);
				_la = _input.LA(1);
				if (_la==T__46) {
					{
					setState(634); match(T__46);
					setState(636);
					_la = _input.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__52) | (1L << T__46) | (1L << ID))) != 0)) {
						{
						setState(635); extParams();
						}
					}

					setState(638); match(T__1);
					}
				}

				setState(644);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__35) {
					{
					{
					setState(641); annotation();
					}
					}
					setState(646);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(647); match(T__25);
				}
				break;
			case 3:
				_localctx = new ExpExtensionContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(648); match(T__11);
				setState(650);
				_la = _input.LA(1);
				if (_la==T__38) {
					{
					setState(649); typeVarTuple();
					}
				}

				setState(652); match(ID);
				setState(658);
				_la = _input.LA(1);
				if (_la==T__46) {
					{
					setState(653); match(T__46);
					setState(655);
					_la = _input.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__52) | (1L << T__46) | (1L << ID))) != 0)) {
						{
						setState(654); extParams();
						}
					}

					setState(657); match(T__1);
					}
				}

				setState(663);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__35) {
					{
					{
					setState(660); annotation();
					}
					}
					setState(665);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(666); match(T__10);
				setState(667); type();
				setState(668); match(T__25);
				}
				break;
			case 4:
				_localctx = new ExpExtensionContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(670); match(T__11);
				setState(672);
				_la = _input.LA(1);
				if (_la==T__38) {
					{
					setState(671); typeVarTuple();
					}
				}

				setState(675);
				switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
				case 1:
					{
					setState(674); type();
					}
					break;
				}
				setState(677); match(ID);
				setState(683);
				_la = _input.LA(1);
				if (_la==T__46) {
					{
					setState(678); match(T__46);
					setState(680);
					_la = _input.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__52) | (1L << T__46) | (1L << ID))) != 0)) {
						{
						setState(679); extParams();
						}
					}

					setState(682); match(T__1);
					}
				}

				setState(688);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__35) {
					{
					{
					setState(685); annotation();
					}
					}
					setState(690);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(691); match(T__25);
				}
				break;
			case 5:
				_localctx = new ProcedureExtensionContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(692); match(T__32);
				setState(694);
				_la = _input.LA(1);
				if (_la==T__38) {
					{
					setState(693); typeVarTuple();
					}
				}

				setState(696); match(ID);
				setState(702);
				_la = _input.LA(1);
				if (_la==T__46) {
					{
					setState(697); match(T__46);
					setState(699);
					_la = _input.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__52) | (1L << T__46) | (1L << ID))) != 0)) {
						{
						setState(698); extParams();
						}
					}

					setState(701); match(T__1);
					}
				}

				setState(707);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__35) {
					{
					{
					setState(704); annotation();
					}
					}
					setState(709);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(710); match(T__10);
				setState(711); type();
				setState(712); match(T__25);
				}
				break;
			case 6:
				_localctx = new ProcedureExtensionContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(714); match(T__32);
				setState(716);
				_la = _input.LA(1);
				if (_la==T__38) {
					{
					setState(715); typeVarTuple();
					}
				}

				setState(719);
				switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
				case 1:
					{
					setState(718); type();
					}
					break;
				}
				setState(721); match(ID);
				setState(727);
				_la = _input.LA(1);
				if (_la==T__46) {
					{
					setState(722); match(T__46);
					setState(724);
					_la = _input.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__52) | (1L << T__46) | (1L << ID))) != 0)) {
						{
						setState(723); extParams();
						}
					}

					setState(726); match(T__1);
					}
				}

				setState(732);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__35) {
					{
					{
					setState(729); annotation();
					}
					}
					setState(734);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(735); match(T__25);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}