
// Generated from SV3_1aPpParser.g4 by ANTLR 4.7.2

#pragma once


#include "antlr4-runtime.h"


class  SV3_1aPpParser : public antlr4::Parser {
public:
  enum {
    One_line_comment = 1, Block_comment = 2, TICK_VARIABLE = 3, TICK_DEFINE = 4, 
    TICK_CELLDEFINE = 5, TICK_ENDCELLDEFINE = 6, TICK_DEFAULT_NETTYPE = 7, 
    TICK_UNDEF = 8, TICK_IFDEF = 9, TICK_IFNDEF = 10, TICK_ELSE = 11, TICK_ELSIF = 12, 
    TICK_ELSEIF = 13, TICK_ENDIF = 14, TICK_INCLUDE = 15, TICK_PRAGMA = 16, 
    TICK_BEGIN_KEYWORDS = 17, TICK_END_KEYWORDS = 18, TICK_RESETALL = 19, 
    TICK_TIMESCALE = 20, TICK_UNCONNECTED_DRIVE = 21, TICK_NOUNCONNECTED_DRIVE = 22, 
    TICK_LINE = 23, TICK_DEFAULT_DECAY_TIME = 24, TICK_DEFAULT_TRIREG_STRENGTH = 25, 
    TICK_DELAY_MODE_DISTRIBUTED = 26, TICK_DELAY_MODE_PATH = 27, TICK_DELAY_MODE_UNIT = 28, 
    TICK_DELAY_MODE_ZERO = 29, TICK_UNDEFINEALL = 30, TICK_ACCELERATE = 31, 
    TICK_NOACCELERATE = 32, TICK_PROTECT = 33, TICK_USELIB = 34, TICK_DISABLE_PORTFAULTS = 35, 
    TICK_ENABLE_PORTFAULTS = 36, TICK_NOSUPPRESS_FAULTS = 37, TICK_SUPPRESS_FAULTS = 38, 
    TICK_SIGNED = 39, TICK_UNSIGNED = 40, TICK_ENDPROTECT = 41, TICK_PROTECTED = 42, 
    TICK_ENDPROTECTED = 43, TICK_EXPAND_VECTORNETS = 44, TICK_NOEXPAND_VECTORNETS = 45, 
    TICK_AUTOEXPAND_VECTORNETS = 46, TICK_REMOVE_GATENAME = 47, TICK_NOREMOVE_GATENAMES = 48, 
    TICK_REMOVE_NETNAME = 49, TICK_NOREMOVE_NETNAMES = 50, TICK_FILE__ = 51, 
    TICK_LINE__ = 52, MODULE = 53, ENDMODULE = 54, INTERFACE = 55, ENDINTERFACE = 56, 
    PROGRAM = 57, ENDPROGRAM = 58, PRIMITIVE = 59, ENDPRIMITIVE = 60, PACKAGE = 61, 
    ENDPACKAGE = 62, CHECKER = 63, ENDCHECKER = 64, CONFIG = 65, ENDCONFIG = 66, 
    Macro_identifier = 67, Macro_Escaped_identifier = 68, String = 69, Simple_identifier = 70, 
    Spaces = 71, Pound_delay = 72, TIMESCALE = 73, Number = 74, Fixed_point_number = 75, 
    TEXT_CR = 76, ESCAPED_CR = 77, CR = 78, TICK_QUOTE = 79, TICK_BACKSLASH_TICK_QUOTE = 80, 
    TICK_TICK = 81, PARENS_OPEN = 82, PARENS_CLOSE = 83, COMMA = 84, EQUAL_OP = 85, 
    DOUBLE_QUOTE = 86, Escaped_identifier = 87, CURLY_OPEN = 88, CURLY_CLOSE = 89, 
    SQUARE_OPEN = 90, SQUARE_CLOSE = 91, Special = 92, ANY = 93
  };

  enum {
    RuleSource_text = 0, RuleDescription = 1, RuleMacro_instance = 2, RuleUnterminated_string = 3, 
    RuleMacro_actual_args = 4, RuleComments = 5, RuleNumber = 6, RulePound_delay = 7, 
    RuleMacro_definition = 8, RuleInclude_directive_one_line = 9, RuleInclude_directive = 10, 
    RuleLine_directive_one_line = 11, RuleLine_directive = 12, RuleDefault_nettype_directive_one_line = 13, 
    RuleDefault_nettype_directive = 14, RuleSv_file_directive = 15, RuleSv_line_directive = 16, 
    RuleTimescale_directive_one_line = 17, RuleTimescale_directive = 18, 
    RuleUndef_directive = 19, RuleIfdef_directive_one_line = 20, RuleIfdef_directive = 21, 
    RuleIfdef_directive_in_macro_body = 22, RuleIfndef_directive_one_line = 23, 
    RuleIfndef_directive = 24, RuleIfndef_directive_in_macro_body = 25, 
    RuleElsif_directive_one_line = 26, RuleElsif_directive = 27, RuleElsif_directive_in_macro_body = 28, 
    RuleElseif_directive_one_line = 29, RuleElseif_directive = 30, RuleElseif_directive_in_macro_body = 31, 
    RuleElse_directive_one_line = 32, RuleElse_directive = 33, RuleEndif_directive_one_line = 34, 
    RuleEndif_directive = 35, RuleResetall_directive_one_line = 36, RuleResetall_directive = 37, 
    RuleBegin_keywords_directive_one_line = 38, RuleBegin_keywords_directive = 39, 
    RuleEnd_keywords_directive_one_line = 40, RuleEnd_keywords_directive = 41, 
    RulePragma_directive_one_line = 42, RulePragma_directive = 43, RuleCelldefine_directive_one_line = 44, 
    RuleCelldefine_directive = 45, RuleEndcelldefine_directive_one_line = 46, 
    RuleEndcelldefine_directive = 47, RuleProtect_directive_one_line = 48, 
    RuleProtect_directive = 49, RuleEndprotect_directive_one_line = 50, 
    RuleEndprotect_directive = 51, RuleProtected_directive_one_line = 52, 
    RuleProtected_directive = 53, RuleEndprotected_directive_one_line = 54, 
    RuleEndprotected_directive = 55, RuleExpand_vectornets_directive_one_line = 56, 
    RuleExpand_vectornets_directive = 57, RuleNoexpand_vectornets_directive_one_line = 58, 
    RuleNoexpand_vectornets_directive = 59, RuleAutoexpand_vectornets_directive_one_line = 60, 
    RuleAutoexpand_vectornets_directive = 61, RuleUselib_directive_one_line = 62, 
    RuleUselib_directive = 63, RuleDisable_portfaults_directive_one_line = 64, 
    RuleDisable_portfaults_directive = 65, RuleEnable_portfaults_directive_one_line = 66, 
    RuleEnable_portfaults_directive = 67, RuleNosuppress_faults_directive_one_line = 68, 
    RuleNosuppress_faults_directive = 69, RuleSuppress_faults_directive_one_line = 70, 
    RuleSuppress_faults_directive = 71, RuleSigned_directive_one_line = 72, 
    RuleSigned_directive = 73, RuleUnsigned_directive_one_line = 74, RuleUnsigned_directive = 75, 
    RuleRemove_gatename_directive_one_line = 76, RuleRemove_gatename_directive = 77, 
    RuleNoremove_gatenames_directive_one_line = 78, RuleNoremove_gatenames_directive = 79, 
    RuleRemove_netname_directive_one_line = 80, RuleRemove_netname_directive = 81, 
    RuleNoremove_netnames_directive_one_line = 82, RuleNoremove_netnames_directive = 83, 
    RuleAccelerate_directive_one_line = 84, RuleAccelerate_directive = 85, 
    RuleNoaccelerate_directive_one_line = 86, RuleNoaccelerate_directive = 87, 
    RuleDefault_trireg_strenght_directive_one_line = 88, RuleDefault_trireg_strenght_directive = 89, 
    RuleDefault_decay_time_directive_one_line = 90, RuleDefault_decay_time_directive = 91, 
    RuleUnconnected_drive_directive_one_line = 92, RuleUnconnected_drive_directive = 93, 
    RuleNounconnected_drive_directive_one_line = 94, RuleNounconnected_drive_directive = 95, 
    RuleDelay_mode_distributed_directive_one_line = 96, RuleDelay_mode_distributed_directive = 97, 
    RuleDelay_mode_path_directive_one_line = 98, RuleDelay_mode_path_directive = 99, 
    RuleDelay_mode_unit_directive_one_line = 100, RuleDelay_mode_unit_directive = 101, 
    RuleDelay_mode_zero_directive_one_line = 102, RuleDelay_mode_zero_directive = 103, 
    RuleUndefineall_directive = 104, RuleModule = 105, RuleEndmodule = 106, 
    RuleSv_interface = 107, RuleEndinterface = 108, RuleProgram = 109, RuleEndprogram = 110, 
    RulePrimitive = 111, RuleEndprimitive = 112, RuleSv_package = 113, RuleEndpackage = 114, 
    RuleChecker = 115, RuleEndchecker = 116, RuleConfig = 117, RuleEndconfig = 118, 
    RuleDefine_directive = 119, RuleMultiline_no_args_macro_definition = 120, 
    RuleMultiline_args_macro_definition = 121, RuleSimple_no_args_macro_definition = 122, 
    RuleSimple_args_macro_definition = 123, RuleIdentifier_in_macro_body = 124, 
    RuleSimple_no_args_macro_definition_in_macro_body = 125, RuleSimple_args_macro_definition_in_macro_body = 126, 
    RuleDirective_in_macro = 127, RuleMacro_arguments = 128, RuleEscaped_macro_definition_body = 129, 
    RuleEscaped_macro_definition_body_alt1 = 130, RuleEscaped_macro_definition_body_alt2 = 131, 
    RuleSimple_macro_definition_body = 132, RuleSimple_macro_definition_body_in_macro_body = 133, 
    RulePragma_expression = 134, RuleMacro_arg = 135, RulePaired_parens = 136, 
    RuleText_blob = 137, RuleString = 138, RuleEscaped_identifier = 139, 
    RuleDefault_value = 140, RuleString_blob = 141
  };

  SV3_1aPpParser(antlr4::TokenStream *input);
  ~SV3_1aPpParser();

  virtual std::string getGrammarFileName() const override;
  virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
  virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
  virtual const std::vector<std::string>& getRuleNames() const override;
  virtual antlr4::dfa::Vocabulary& getVocabulary() const override;


  class Source_textContext;
  class DescriptionContext;
  class Macro_instanceContext;
  class Unterminated_stringContext;
  class Macro_actual_argsContext;
  class CommentsContext;
  class NumberContext;
  class Pound_delayContext;
  class Macro_definitionContext;
  class Include_directive_one_lineContext;
  class Include_directiveContext;
  class Line_directive_one_lineContext;
  class Line_directiveContext;
  class Default_nettype_directive_one_lineContext;
  class Default_nettype_directiveContext;
  class Sv_file_directiveContext;
  class Sv_line_directiveContext;
  class Timescale_directive_one_lineContext;
  class Timescale_directiveContext;
  class Undef_directiveContext;
  class Ifdef_directive_one_lineContext;
  class Ifdef_directiveContext;
  class Ifdef_directive_in_macro_bodyContext;
  class Ifndef_directive_one_lineContext;
  class Ifndef_directiveContext;
  class Ifndef_directive_in_macro_bodyContext;
  class Elsif_directive_one_lineContext;
  class Elsif_directiveContext;
  class Elsif_directive_in_macro_bodyContext;
  class Elseif_directive_one_lineContext;
  class Elseif_directiveContext;
  class Elseif_directive_in_macro_bodyContext;
  class Else_directive_one_lineContext;
  class Else_directiveContext;
  class Endif_directive_one_lineContext;
  class Endif_directiveContext;
  class Resetall_directive_one_lineContext;
  class Resetall_directiveContext;
  class Begin_keywords_directive_one_lineContext;
  class Begin_keywords_directiveContext;
  class End_keywords_directive_one_lineContext;
  class End_keywords_directiveContext;
  class Pragma_directive_one_lineContext;
  class Pragma_directiveContext;
  class Celldefine_directive_one_lineContext;
  class Celldefine_directiveContext;
  class Endcelldefine_directive_one_lineContext;
  class Endcelldefine_directiveContext;
  class Protect_directive_one_lineContext;
  class Protect_directiveContext;
  class Endprotect_directive_one_lineContext;
  class Endprotect_directiveContext;
  class Protected_directive_one_lineContext;
  class Protected_directiveContext;
  class Endprotected_directive_one_lineContext;
  class Endprotected_directiveContext;
  class Expand_vectornets_directive_one_lineContext;
  class Expand_vectornets_directiveContext;
  class Noexpand_vectornets_directive_one_lineContext;
  class Noexpand_vectornets_directiveContext;
  class Autoexpand_vectornets_directive_one_lineContext;
  class Autoexpand_vectornets_directiveContext;
  class Uselib_directive_one_lineContext;
  class Uselib_directiveContext;
  class Disable_portfaults_directive_one_lineContext;
  class Disable_portfaults_directiveContext;
  class Enable_portfaults_directive_one_lineContext;
  class Enable_portfaults_directiveContext;
  class Nosuppress_faults_directive_one_lineContext;
  class Nosuppress_faults_directiveContext;
  class Suppress_faults_directive_one_lineContext;
  class Suppress_faults_directiveContext;
  class Signed_directive_one_lineContext;
  class Signed_directiveContext;
  class Unsigned_directive_one_lineContext;
  class Unsigned_directiveContext;
  class Remove_gatename_directive_one_lineContext;
  class Remove_gatename_directiveContext;
  class Noremove_gatenames_directive_one_lineContext;
  class Noremove_gatenames_directiveContext;
  class Remove_netname_directive_one_lineContext;
  class Remove_netname_directiveContext;
  class Noremove_netnames_directive_one_lineContext;
  class Noremove_netnames_directiveContext;
  class Accelerate_directive_one_lineContext;
  class Accelerate_directiveContext;
  class Noaccelerate_directive_one_lineContext;
  class Noaccelerate_directiveContext;
  class Default_trireg_strenght_directive_one_lineContext;
  class Default_trireg_strenght_directiveContext;
  class Default_decay_time_directive_one_lineContext;
  class Default_decay_time_directiveContext;
  class Unconnected_drive_directive_one_lineContext;
  class Unconnected_drive_directiveContext;
  class Nounconnected_drive_directive_one_lineContext;
  class Nounconnected_drive_directiveContext;
  class Delay_mode_distributed_directive_one_lineContext;
  class Delay_mode_distributed_directiveContext;
  class Delay_mode_path_directive_one_lineContext;
  class Delay_mode_path_directiveContext;
  class Delay_mode_unit_directive_one_lineContext;
  class Delay_mode_unit_directiveContext;
  class Delay_mode_zero_directive_one_lineContext;
  class Delay_mode_zero_directiveContext;
  class Undefineall_directiveContext;
  class ModuleContext;
  class EndmoduleContext;
  class Sv_interfaceContext;
  class EndinterfaceContext;
  class ProgramContext;
  class EndprogramContext;
  class PrimitiveContext;
  class EndprimitiveContext;
  class Sv_packageContext;
  class EndpackageContext;
  class CheckerContext;
  class EndcheckerContext;
  class ConfigContext;
  class EndconfigContext;
  class Define_directiveContext;
  class Multiline_no_args_macro_definitionContext;
  class Multiline_args_macro_definitionContext;
  class Simple_no_args_macro_definitionContext;
  class Simple_args_macro_definitionContext;
  class Identifier_in_macro_bodyContext;
  class Simple_no_args_macro_definition_in_macro_bodyContext;
  class Simple_args_macro_definition_in_macro_bodyContext;
  class Directive_in_macroContext;
  class Macro_argumentsContext;
  class Escaped_macro_definition_bodyContext;
  class Escaped_macro_definition_body_alt1Context;
  class Escaped_macro_definition_body_alt2Context;
  class Simple_macro_definition_bodyContext;
  class Simple_macro_definition_body_in_macro_bodyContext;
  class Pragma_expressionContext;
  class Macro_argContext;
  class Paired_parensContext;
  class Text_blobContext;
  class StringContext;
  class Escaped_identifierContext;
  class Default_valueContext;
  class String_blobContext; 

  class  Source_textContext : public antlr4::ParserRuleContext {
  public:
    Source_textContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<DescriptionContext *> description();
    DescriptionContext* description(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Source_textContext* source_text();

  class  DescriptionContext : public antlr4::ParserRuleContext {
  public:
    DescriptionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Unterminated_stringContext *unterminated_string();
    StringContext *string();
    NumberContext *number();
    Macro_definitionContext *macro_definition();
    CommentsContext *comments();
    Celldefine_directive_one_lineContext *celldefine_directive_one_line();
    Endcelldefine_directive_one_lineContext *endcelldefine_directive_one_line();
    Default_nettype_directive_one_lineContext *default_nettype_directive_one_line();
    Undef_directiveContext *undef_directive();
    Ifdef_directive_one_lineContext *ifdef_directive_one_line();
    Ifndef_directive_one_lineContext *ifndef_directive_one_line();
    Else_directive_one_lineContext *else_directive_one_line();
    Elsif_directive_one_lineContext *elsif_directive_one_line();
    Elseif_directive_one_lineContext *elseif_directive_one_line();
    Endif_directive_one_lineContext *endif_directive_one_line();
    Include_directive_one_lineContext *include_directive_one_line();
    Include_directiveContext *include_directive();
    Resetall_directive_one_lineContext *resetall_directive_one_line();
    Begin_keywords_directive_one_lineContext *begin_keywords_directive_one_line();
    Begin_keywords_directiveContext *begin_keywords_directive();
    End_keywords_directive_one_lineContext *end_keywords_directive_one_line();
    Timescale_directive_one_lineContext *timescale_directive_one_line();
    Unconnected_drive_directive_one_lineContext *unconnected_drive_directive_one_line();
    Nounconnected_drive_directive_one_lineContext *nounconnected_drive_directive_one_line();
    Line_directive_one_lineContext *line_directive_one_line();
    Default_decay_time_directive_one_lineContext *default_decay_time_directive_one_line();
    Default_trireg_strenght_directive_one_lineContext *default_trireg_strenght_directive_one_line();
    Delay_mode_distributed_directive_one_lineContext *delay_mode_distributed_directive_one_line();
    Delay_mode_path_directive_one_lineContext *delay_mode_path_directive_one_line();
    Delay_mode_unit_directive_one_lineContext *delay_mode_unit_directive_one_line();
    Delay_mode_zero_directive_one_lineContext *delay_mode_zero_directive_one_line();
    Protect_directive_one_lineContext *protect_directive_one_line();
    Endprotect_directive_one_lineContext *endprotect_directive_one_line();
    Protected_directive_one_lineContext *protected_directive_one_line();
    Endprotected_directive_one_lineContext *endprotected_directive_one_line();
    Expand_vectornets_directive_one_lineContext *expand_vectornets_directive_one_line();
    Noexpand_vectornets_directive_one_lineContext *noexpand_vectornets_directive_one_line();
    Autoexpand_vectornets_directive_one_lineContext *autoexpand_vectornets_directive_one_line();
    Remove_gatename_directive_one_lineContext *remove_gatename_directive_one_line();
    Noremove_gatenames_directive_one_lineContext *noremove_gatenames_directive_one_line();
    Remove_netname_directive_one_lineContext *remove_netname_directive_one_line();
    Noremove_netnames_directive_one_lineContext *noremove_netnames_directive_one_line();
    Accelerate_directive_one_lineContext *accelerate_directive_one_line();
    Noaccelerate_directive_one_lineContext *noaccelerate_directive_one_line();
    Undefineall_directiveContext *undefineall_directive();
    Uselib_directive_one_lineContext *uselib_directive_one_line();
    Disable_portfaults_directive_one_lineContext *disable_portfaults_directive_one_line();
    Enable_portfaults_directive_one_lineContext *enable_portfaults_directive_one_line();
    Nosuppress_faults_directive_one_lineContext *nosuppress_faults_directive_one_line();
    Suppress_faults_directive_one_lineContext *suppress_faults_directive_one_line();
    Signed_directive_one_lineContext *signed_directive_one_line();
    Unsigned_directive_one_lineContext *unsigned_directive_one_line();
    Pragma_directive_one_lineContext *pragma_directive_one_line();
    Sv_file_directiveContext *sv_file_directive();
    Sv_line_directiveContext *sv_line_directive();
    Macro_instanceContext *macro_instance();
    ModuleContext *module();
    EndmoduleContext *endmodule();
    Sv_interfaceContext *sv_interface();
    EndinterfaceContext *endinterface();
    ProgramContext *program();
    EndprogramContext *endprogram();
    PrimitiveContext *primitive();
    EndprimitiveContext *endprimitive();
    Sv_packageContext *sv_package();
    EndpackageContext *endpackage();
    CheckerContext *checker();
    EndcheckerContext *endchecker();
    ConfigContext *config();
    EndconfigContext *endconfig();
    Text_blobContext *text_blob();
    Escaped_identifierContext *escaped_identifier();
    Pound_delayContext *pound_delay();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  DescriptionContext* description();

  class  Macro_instanceContext : public antlr4::ParserRuleContext {
  public:
    Macro_instanceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    Macro_instanceContext() = default;
    void copyFrom(Macro_instanceContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  MacroInstanceWithArgsContext : public Macro_instanceContext {
  public:
    MacroInstanceWithArgsContext(Macro_instanceContext *ctx);

    antlr4::tree::TerminalNode *PARENS_OPEN();
    Macro_actual_argsContext *macro_actual_args();
    antlr4::tree::TerminalNode *PARENS_CLOSE();
    antlr4::tree::TerminalNode *Macro_identifier();
    antlr4::tree::TerminalNode *Macro_Escaped_identifier();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
  };

  class  MacroInstanceNoArgsContext : public Macro_instanceContext {
  public:
    MacroInstanceNoArgsContext(Macro_instanceContext *ctx);

    antlr4::tree::TerminalNode *Macro_identifier();
    antlr4::tree::TerminalNode *Macro_Escaped_identifier();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
  };

  Macro_instanceContext* macro_instance();

  class  Unterminated_stringContext : public antlr4::ParserRuleContext {
  public:
    Unterminated_stringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *DOUBLE_QUOTE();
    antlr4::tree::TerminalNode *CR();
    std::vector<String_blobContext *> string_blob();
    String_blobContext* string_blob(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Unterminated_stringContext* unterminated_string();

  class  Macro_actual_argsContext : public antlr4::ParserRuleContext {
  public:
    Macro_actual_argsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Macro_argContext *> macro_arg();
    Macro_argContext* macro_arg(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Macro_actual_argsContext* macro_actual_args();

  class  CommentsContext : public antlr4::ParserRuleContext {
  public:
    CommentsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *One_line_comment();
    antlr4::tree::TerminalNode *Block_comment();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  CommentsContext* comments();

  class  NumberContext : public antlr4::ParserRuleContext {
  public:
    NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Number();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  NumberContext* number();

  class  Pound_delayContext : public antlr4::ParserRuleContext {
  public:
    Pound_delayContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Pound_delay();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Pound_delayContext* pound_delay();

  class  Macro_definitionContext : public antlr4::ParserRuleContext {
  public:
    Macro_definitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Define_directiveContext *define_directive();
    Multiline_args_macro_definitionContext *multiline_args_macro_definition();
    Simple_no_args_macro_definitionContext *simple_no_args_macro_definition();
    Multiline_no_args_macro_definitionContext *multiline_no_args_macro_definition();
    Simple_args_macro_definitionContext *simple_args_macro_definition();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Macro_definitionContext* macro_definition();

  class  Include_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Include_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Include_directiveContext *include_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Include_directive_one_lineContext* include_directive_one_line();

  class  Include_directiveContext : public antlr4::ParserRuleContext {
  public:
    Include_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_INCLUDE();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *String();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Include_directiveContext* include_directive();

  class  Line_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Line_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Line_directiveContext *line_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Line_directive_one_lineContext* line_directive_one_line();

  class  Line_directiveContext : public antlr4::ParserRuleContext {
  public:
    Line_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_LINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<NumberContext *> number();
    NumberContext* number(size_t i);
    antlr4::tree::TerminalNode *String();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Line_directiveContext* line_directive();

  class  Default_nettype_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Default_nettype_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Default_nettype_directiveContext *default_nettype_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_nettype_directive_one_lineContext* default_nettype_directive_one_line();

  class  Default_nettype_directiveContext : public antlr4::ParserRuleContext {
  public:
    Default_nettype_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFAULT_NETTYPE();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_nettype_directiveContext* default_nettype_directive();

  class  Sv_file_directiveContext : public antlr4::ParserRuleContext {
  public:
    Sv_file_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_FILE__();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Sv_file_directiveContext* sv_file_directive();

  class  Sv_line_directiveContext : public antlr4::ParserRuleContext {
  public:
    Sv_line_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_LINE__();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Sv_line_directiveContext* sv_line_directive();

  class  Timescale_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Timescale_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Timescale_directiveContext *timescale_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Timescale_directive_one_lineContext* timescale_directive_one_line();

  class  Timescale_directiveContext : public antlr4::ParserRuleContext {
  public:
    Timescale_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_TIMESCALE();
    antlr4::tree::TerminalNode *TIMESCALE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Timescale_directiveContext* timescale_directive();

  class  Undef_directiveContext : public antlr4::ParserRuleContext {
  public:
    Undef_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_UNDEF();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Undef_directiveContext* undef_directive();

  class  Ifdef_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Ifdef_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ifdef_directiveContext *ifdef_directive();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    antlr4::tree::TerminalNode *One_line_comment();
    antlr4::tree::TerminalNode *CR();
    Endif_directiveContext *endif_directive();
    std::vector<DescriptionContext *> description();
    DescriptionContext* description(size_t i);
    std::vector<Else_directiveContext *> else_directive();
    Else_directiveContext* else_directive(size_t i);
    std::vector<Elseif_directiveContext *> elseif_directive();
    Elseif_directiveContext* elseif_directive(size_t i);
    std::vector<Elsif_directiveContext *> elsif_directive();
    Elsif_directiveContext* elsif_directive(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Ifdef_directive_one_lineContext* ifdef_directive_one_line();

  class  Ifdef_directiveContext : public antlr4::ParserRuleContext {
  public:
    Ifdef_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_IFDEF();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Ifdef_directiveContext* ifdef_directive();

  class  Ifdef_directive_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Ifdef_directive_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_IFDEF();
    antlr4::tree::TerminalNode *Spaces();
    Identifier_in_macro_bodyContext *identifier_in_macro_body();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Ifdef_directive_in_macro_bodyContext* ifdef_directive_in_macro_body();

  class  Ifndef_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Ifndef_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Ifndef_directiveContext *ifndef_directive();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    antlr4::tree::TerminalNode *One_line_comment();
    antlr4::tree::TerminalNode *CR();
    Endif_directiveContext *endif_directive();
    std::vector<DescriptionContext *> description();
    DescriptionContext* description(size_t i);
    std::vector<Else_directiveContext *> else_directive();
    Else_directiveContext* else_directive(size_t i);
    std::vector<Elseif_directiveContext *> elseif_directive();
    Elseif_directiveContext* elseif_directive(size_t i);
    std::vector<Elsif_directiveContext *> elsif_directive();
    Elsif_directiveContext* elsif_directive(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Ifndef_directive_one_lineContext* ifndef_directive_one_line();

  class  Ifndef_directiveContext : public antlr4::ParserRuleContext {
  public:
    Ifndef_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_IFNDEF();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Ifndef_directiveContext* ifndef_directive();

  class  Ifndef_directive_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Ifndef_directive_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_IFNDEF();
    antlr4::tree::TerminalNode *Spaces();
    Identifier_in_macro_bodyContext *identifier_in_macro_body();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Ifndef_directive_in_macro_bodyContext* ifndef_directive_in_macro_body();

  class  Elsif_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Elsif_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Elsif_directiveContext *elsif_directive();
    antlr4::tree::TerminalNode *One_line_comment();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Elsif_directive_one_lineContext* elsif_directive_one_line();

  class  Elsif_directiveContext : public antlr4::ParserRuleContext {
  public:
    Elsif_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ELSIF();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Elsif_directiveContext* elsif_directive();

  class  Elsif_directive_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Elsif_directive_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ELSIF();
    antlr4::tree::TerminalNode *Spaces();
    Identifier_in_macro_bodyContext *identifier_in_macro_body();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Elsif_directive_in_macro_bodyContext* elsif_directive_in_macro_body();

  class  Elseif_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Elseif_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Elseif_directiveContext *elseif_directive();
    antlr4::tree::TerminalNode *One_line_comment();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Elseif_directive_one_lineContext* elseif_directive_one_line();

  class  Elseif_directiveContext : public antlr4::ParserRuleContext {
  public:
    Elseif_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ELSEIF();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Elseif_directiveContext* elseif_directive();

  class  Elseif_directive_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Elseif_directive_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ELSEIF();
    antlr4::tree::TerminalNode *Spaces();
    Identifier_in_macro_bodyContext *identifier_in_macro_body();
    antlr4::tree::TerminalNode *Escaped_identifier();
    Macro_instanceContext *macro_instance();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Elseif_directive_in_macro_bodyContext* elseif_directive_in_macro_body();

  class  Else_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Else_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Else_directiveContext *else_directive();
    antlr4::tree::TerminalNode *One_line_comment();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Else_directive_one_lineContext* else_directive_one_line();

  class  Else_directiveContext : public antlr4::ParserRuleContext {
  public:
    Else_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ELSE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Else_directiveContext* else_directive();

  class  Endif_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Endif_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ENDIF();
    antlr4::tree::TerminalNode *One_line_comment();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *EOF();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endif_directive_one_lineContext* endif_directive_one_line();

  class  Endif_directiveContext : public antlr4::ParserRuleContext {
  public:
    Endif_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ENDIF();
    antlr4::tree::TerminalNode *One_line_comment();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endif_directiveContext* endif_directive();

  class  Resetall_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Resetall_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Resetall_directiveContext *resetall_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Resetall_directive_one_lineContext* resetall_directive_one_line();

  class  Resetall_directiveContext : public antlr4::ParserRuleContext {
  public:
    Resetall_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_RESETALL();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Resetall_directiveContext* resetall_directive();

  class  Begin_keywords_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Begin_keywords_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Begin_keywords_directiveContext *begin_keywords_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Begin_keywords_directive_one_lineContext* begin_keywords_directive_one_line();

  class  Begin_keywords_directiveContext : public antlr4::ParserRuleContext {
  public:
    Begin_keywords_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_BEGIN_KEYWORDS();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *String();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Begin_keywords_directiveContext* begin_keywords_directive();

  class  End_keywords_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    End_keywords_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    End_keywords_directiveContext *end_keywords_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  End_keywords_directive_one_lineContext* end_keywords_directive_one_line();

  class  End_keywords_directiveContext : public antlr4::ParserRuleContext {
  public:
    End_keywords_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_END_KEYWORDS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  End_keywords_directiveContext* end_keywords_directive();

  class  Pragma_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Pragma_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Pragma_directiveContext *pragma_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Pragma_directive_one_lineContext* pragma_directive_one_line();

  class  Pragma_directiveContext : public antlr4::ParserRuleContext {
  public:
    Pragma_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_PRAGMA();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();
    std::vector<Pragma_expressionContext *> pragma_expression();
    Pragma_expressionContext* pragma_expression(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Special();
    antlr4::tree::TerminalNode* Special(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Pragma_directiveContext* pragma_directive();

  class  Celldefine_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Celldefine_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Celldefine_directiveContext *celldefine_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Celldefine_directive_one_lineContext* celldefine_directive_one_line();

  class  Celldefine_directiveContext : public antlr4::ParserRuleContext {
  public:
    Celldefine_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_CELLDEFINE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Celldefine_directiveContext* celldefine_directive();

  class  Endcelldefine_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Endcelldefine_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Endcelldefine_directiveContext *endcelldefine_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endcelldefine_directive_one_lineContext* endcelldefine_directive_one_line();

  class  Endcelldefine_directiveContext : public antlr4::ParserRuleContext {
  public:
    Endcelldefine_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ENDCELLDEFINE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endcelldefine_directiveContext* endcelldefine_directive();

  class  Protect_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Protect_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Protect_directiveContext *protect_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Protect_directive_one_lineContext* protect_directive_one_line();

  class  Protect_directiveContext : public antlr4::ParserRuleContext {
  public:
    Protect_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_PROTECT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Protect_directiveContext* protect_directive();

  class  Endprotect_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Endprotect_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Endprotect_directiveContext *endprotect_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endprotect_directive_one_lineContext* endprotect_directive_one_line();

  class  Endprotect_directiveContext : public antlr4::ParserRuleContext {
  public:
    Endprotect_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ENDPROTECT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endprotect_directiveContext* endprotect_directive();

  class  Protected_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Protected_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Protected_directiveContext *protected_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Protected_directive_one_lineContext* protected_directive_one_line();

  class  Protected_directiveContext : public antlr4::ParserRuleContext {
  public:
    Protected_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_PROTECTED();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Protected_directiveContext* protected_directive();

  class  Endprotected_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Endprotected_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Endprotected_directiveContext *endprotected_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endprotected_directive_one_lineContext* endprotected_directive_one_line();

  class  Endprotected_directiveContext : public antlr4::ParserRuleContext {
  public:
    Endprotected_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ENDPROTECTED();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Endprotected_directiveContext* endprotected_directive();

  class  Expand_vectornets_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Expand_vectornets_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Expand_vectornets_directiveContext *expand_vectornets_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Expand_vectornets_directive_one_lineContext* expand_vectornets_directive_one_line();

  class  Expand_vectornets_directiveContext : public antlr4::ParserRuleContext {
  public:
    Expand_vectornets_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_EXPAND_VECTORNETS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Expand_vectornets_directiveContext* expand_vectornets_directive();

  class  Noexpand_vectornets_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Noexpand_vectornets_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Noexpand_vectornets_directiveContext *noexpand_vectornets_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noexpand_vectornets_directive_one_lineContext* noexpand_vectornets_directive_one_line();

  class  Noexpand_vectornets_directiveContext : public antlr4::ParserRuleContext {
  public:
    Noexpand_vectornets_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_NOEXPAND_VECTORNETS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noexpand_vectornets_directiveContext* noexpand_vectornets_directive();

  class  Autoexpand_vectornets_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Autoexpand_vectornets_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Autoexpand_vectornets_directiveContext *autoexpand_vectornets_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Autoexpand_vectornets_directive_one_lineContext* autoexpand_vectornets_directive_one_line();

  class  Autoexpand_vectornets_directiveContext : public antlr4::ParserRuleContext {
  public:
    Autoexpand_vectornets_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_AUTOEXPAND_VECTORNETS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Autoexpand_vectornets_directiveContext* autoexpand_vectornets_directive();

  class  Uselib_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Uselib_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Uselib_directiveContext *uselib_directive();
    antlr4::tree::TerminalNode *CR();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Uselib_directive_one_lineContext* uselib_directive_one_line();

  class  Uselib_directiveContext : public antlr4::ParserRuleContext {
  public:
    Uselib_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_USELIB();
    std::vector<Text_blobContext *> text_blob();
    Text_blobContext* text_blob(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Uselib_directiveContext* uselib_directive();

  class  Disable_portfaults_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Disable_portfaults_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Disable_portfaults_directiveContext *disable_portfaults_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Disable_portfaults_directive_one_lineContext* disable_portfaults_directive_one_line();

  class  Disable_portfaults_directiveContext : public antlr4::ParserRuleContext {
  public:
    Disable_portfaults_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DISABLE_PORTFAULTS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Disable_portfaults_directiveContext* disable_portfaults_directive();

  class  Enable_portfaults_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Enable_portfaults_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Enable_portfaults_directiveContext *enable_portfaults_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Enable_portfaults_directive_one_lineContext* enable_portfaults_directive_one_line();

  class  Enable_portfaults_directiveContext : public antlr4::ParserRuleContext {
  public:
    Enable_portfaults_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ENABLE_PORTFAULTS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Enable_portfaults_directiveContext* enable_portfaults_directive();

  class  Nosuppress_faults_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Nosuppress_faults_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Nosuppress_faults_directiveContext *nosuppress_faults_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Nosuppress_faults_directive_one_lineContext* nosuppress_faults_directive_one_line();

  class  Nosuppress_faults_directiveContext : public antlr4::ParserRuleContext {
  public:
    Nosuppress_faults_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_NOSUPPRESS_FAULTS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Nosuppress_faults_directiveContext* nosuppress_faults_directive();

  class  Suppress_faults_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Suppress_faults_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Suppress_faults_directiveContext *suppress_faults_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Suppress_faults_directive_one_lineContext* suppress_faults_directive_one_line();

  class  Suppress_faults_directiveContext : public antlr4::ParserRuleContext {
  public:
    Suppress_faults_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_SUPPRESS_FAULTS();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Suppress_faults_directiveContext* suppress_faults_directive();

  class  Signed_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Signed_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Signed_directiveContext *signed_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Signed_directive_one_lineContext* signed_directive_one_line();

  class  Signed_directiveContext : public antlr4::ParserRuleContext {
  public:
    Signed_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_SIGNED();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Signed_directiveContext* signed_directive();

  class  Unsigned_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Unsigned_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Unsigned_directiveContext *unsigned_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Unsigned_directive_one_lineContext* unsigned_directive_one_line();

  class  Unsigned_directiveContext : public antlr4::ParserRuleContext {
  public:
    Unsigned_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_UNSIGNED();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Unsigned_directiveContext* unsigned_directive();

  class  Remove_gatename_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Remove_gatename_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Remove_gatename_directiveContext *remove_gatename_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Remove_gatename_directive_one_lineContext* remove_gatename_directive_one_line();

  class  Remove_gatename_directiveContext : public antlr4::ParserRuleContext {
  public:
    Remove_gatename_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_REMOVE_GATENAME();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Remove_gatename_directiveContext* remove_gatename_directive();

  class  Noremove_gatenames_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Noremove_gatenames_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Noremove_gatenames_directiveContext *noremove_gatenames_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noremove_gatenames_directive_one_lineContext* noremove_gatenames_directive_one_line();

  class  Noremove_gatenames_directiveContext : public antlr4::ParserRuleContext {
  public:
    Noremove_gatenames_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_NOREMOVE_GATENAMES();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noremove_gatenames_directiveContext* noremove_gatenames_directive();

  class  Remove_netname_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Remove_netname_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Remove_netname_directiveContext *remove_netname_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Remove_netname_directive_one_lineContext* remove_netname_directive_one_line();

  class  Remove_netname_directiveContext : public antlr4::ParserRuleContext {
  public:
    Remove_netname_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_REMOVE_NETNAME();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Remove_netname_directiveContext* remove_netname_directive();

  class  Noremove_netnames_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Noremove_netnames_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Noremove_netnames_directiveContext *noremove_netnames_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noremove_netnames_directive_one_lineContext* noremove_netnames_directive_one_line();

  class  Noremove_netnames_directiveContext : public antlr4::ParserRuleContext {
  public:
    Noremove_netnames_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_NOREMOVE_NETNAMES();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noremove_netnames_directiveContext* noremove_netnames_directive();

  class  Accelerate_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Accelerate_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Accelerate_directiveContext *accelerate_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Accelerate_directive_one_lineContext* accelerate_directive_one_line();

  class  Accelerate_directiveContext : public antlr4::ParserRuleContext {
  public:
    Accelerate_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_ACCELERATE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Accelerate_directiveContext* accelerate_directive();

  class  Noaccelerate_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Noaccelerate_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Noaccelerate_directiveContext *noaccelerate_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noaccelerate_directive_one_lineContext* noaccelerate_directive_one_line();

  class  Noaccelerate_directiveContext : public antlr4::ParserRuleContext {
  public:
    Noaccelerate_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_NOACCELERATE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Noaccelerate_directiveContext* noaccelerate_directive();

  class  Default_trireg_strenght_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Default_trireg_strenght_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Default_trireg_strenght_directiveContext *default_trireg_strenght_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_trireg_strenght_directive_one_lineContext* default_trireg_strenght_directive_one_line();

  class  Default_trireg_strenght_directiveContext : public antlr4::ParserRuleContext {
  public:
    Default_trireg_strenght_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFAULT_TRIREG_STRENGTH();
    antlr4::tree::TerminalNode *Spaces();
    NumberContext *number();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_trireg_strenght_directiveContext* default_trireg_strenght_directive();

  class  Default_decay_time_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Default_decay_time_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Default_decay_time_directiveContext *default_decay_time_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_decay_time_directive_one_lineContext* default_decay_time_directive_one_line();

  class  Default_decay_time_directiveContext : public antlr4::ParserRuleContext {
  public:
    Default_decay_time_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFAULT_DECAY_TIME();
    antlr4::tree::TerminalNode *Spaces();
    NumberContext *number();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Fixed_point_number();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_decay_time_directiveContext* default_decay_time_directive();

  class  Unconnected_drive_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Unconnected_drive_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Unconnected_drive_directiveContext *unconnected_drive_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Unconnected_drive_directive_one_lineContext* unconnected_drive_directive_one_line();

  class  Unconnected_drive_directiveContext : public antlr4::ParserRuleContext {
  public:
    Unconnected_drive_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_UNCONNECTED_DRIVE();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Simple_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Unconnected_drive_directiveContext* unconnected_drive_directive();

  class  Nounconnected_drive_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Nounconnected_drive_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Nounconnected_drive_directiveContext *nounconnected_drive_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Nounconnected_drive_directive_one_lineContext* nounconnected_drive_directive_one_line();

  class  Nounconnected_drive_directiveContext : public antlr4::ParserRuleContext {
  public:
    Nounconnected_drive_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_NOUNCONNECTED_DRIVE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Nounconnected_drive_directiveContext* nounconnected_drive_directive();

  class  Delay_mode_distributed_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_distributed_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Delay_mode_distributed_directiveContext *delay_mode_distributed_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_distributed_directive_one_lineContext* delay_mode_distributed_directive_one_line();

  class  Delay_mode_distributed_directiveContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_distributed_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DELAY_MODE_DISTRIBUTED();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_distributed_directiveContext* delay_mode_distributed_directive();

  class  Delay_mode_path_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_path_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Delay_mode_path_directiveContext *delay_mode_path_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_path_directive_one_lineContext* delay_mode_path_directive_one_line();

  class  Delay_mode_path_directiveContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_path_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DELAY_MODE_PATH();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_path_directiveContext* delay_mode_path_directive();

  class  Delay_mode_unit_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_unit_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Delay_mode_unit_directiveContext *delay_mode_unit_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_unit_directive_one_lineContext* delay_mode_unit_directive_one_line();

  class  Delay_mode_unit_directiveContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_unit_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DELAY_MODE_UNIT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_unit_directiveContext* delay_mode_unit_directive();

  class  Delay_mode_zero_directive_one_lineContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_zero_directive_one_lineContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Delay_mode_zero_directiveContext *delay_mode_zero_directive();
    antlr4::tree::TerminalNode *CR();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_zero_directive_one_lineContext* delay_mode_zero_directive_one_line();

  class  Delay_mode_zero_directiveContext : public antlr4::ParserRuleContext {
  public:
    Delay_mode_zero_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DELAY_MODE_ZERO();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Delay_mode_zero_directiveContext* delay_mode_zero_directive();

  class  Undefineall_directiveContext : public antlr4::ParserRuleContext {
  public:
    Undefineall_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_UNDEFINEALL();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Undefineall_directiveContext* undefineall_directive();

  class  ModuleContext : public antlr4::ParserRuleContext {
  public:
    ModuleContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *MODULE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  ModuleContext* module();

  class  EndmoduleContext : public antlr4::ParserRuleContext {
  public:
    EndmoduleContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDMODULE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndmoduleContext* endmodule();

  class  Sv_interfaceContext : public antlr4::ParserRuleContext {
  public:
    Sv_interfaceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *INTERFACE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Sv_interfaceContext* sv_interface();

  class  EndinterfaceContext : public antlr4::ParserRuleContext {
  public:
    EndinterfaceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDINTERFACE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndinterfaceContext* endinterface();

  class  ProgramContext : public antlr4::ParserRuleContext {
  public:
    ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PROGRAM();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  ProgramContext* program();

  class  EndprogramContext : public antlr4::ParserRuleContext {
  public:
    EndprogramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDPROGRAM();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndprogramContext* endprogram();

  class  PrimitiveContext : public antlr4::ParserRuleContext {
  public:
    PrimitiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PRIMITIVE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  PrimitiveContext* primitive();

  class  EndprimitiveContext : public antlr4::ParserRuleContext {
  public:
    EndprimitiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDPRIMITIVE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndprimitiveContext* endprimitive();

  class  Sv_packageContext : public antlr4::ParserRuleContext {
  public:
    Sv_packageContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PACKAGE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Sv_packageContext* sv_package();

  class  EndpackageContext : public antlr4::ParserRuleContext {
  public:
    EndpackageContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDPACKAGE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndpackageContext* endpackage();

  class  CheckerContext : public antlr4::ParserRuleContext {
  public:
    CheckerContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *CHECKER();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  CheckerContext* checker();

  class  EndcheckerContext : public antlr4::ParserRuleContext {
  public:
    EndcheckerContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDCHECKER();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndcheckerContext* endchecker();

  class  ConfigContext : public antlr4::ParserRuleContext {
  public:
    ConfigContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *CONFIG();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  ConfigContext* config();

  class  EndconfigContext : public antlr4::ParserRuleContext {
  public:
    EndconfigContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ENDCONFIG();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  EndconfigContext* endconfig();

  class  Define_directiveContext : public antlr4::ParserRuleContext {
  public:
    Define_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Define_directiveContext* define_directive();

  class  Multiline_no_args_macro_definitionContext : public antlr4::ParserRuleContext {
  public:
    Multiline_no_args_macro_definitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    Escaped_macro_definition_bodyContext *escaped_macro_definition_body();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Multiline_no_args_macro_definitionContext* multiline_no_args_macro_definition();

  class  Multiline_args_macro_definitionContext : public antlr4::ParserRuleContext {
  public:
    Multiline_args_macro_definitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    Macro_argumentsContext *macro_arguments();
    Escaped_macro_definition_bodyContext *escaped_macro_definition_body();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Multiline_args_macro_definitionContext* multiline_args_macro_definition();

  class  Simple_no_args_macro_definitionContext : public antlr4::ParserRuleContext {
  public:
    Simple_no_args_macro_definitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    Simple_macro_definition_bodyContext *simple_macro_definition_body();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *One_line_comment();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Simple_no_args_macro_definitionContext* simple_no_args_macro_definition();

  class  Simple_args_macro_definitionContext : public antlr4::ParserRuleContext {
  public:
    Simple_args_macro_definitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    Macro_argumentsContext *macro_arguments();
    Simple_macro_definition_bodyContext *simple_macro_definition_body();
    antlr4::tree::TerminalNode *Simple_identifier();
    antlr4::tree::TerminalNode *Escaped_identifier();
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *One_line_comment();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Simple_args_macro_definitionContext* simple_args_macro_definition();

  class  Identifier_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Identifier_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_TICK();
    antlr4::tree::TerminalNode* TICK_TICK(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Identifier_in_macro_bodyContext* identifier_in_macro_body();

  class  Simple_no_args_macro_definition_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Simple_no_args_macro_definition_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    Simple_macro_definition_body_in_macro_bodyContext *simple_macro_definition_body_in_macro_body();
    Identifier_in_macro_bodyContext *identifier_in_macro_body();
    antlr4::tree::TerminalNode *Escaped_identifier();
    antlr4::tree::TerminalNode *TICK_VARIABLE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Simple_no_args_macro_definition_in_macro_bodyContext* simple_no_args_macro_definition_in_macro_body();

  class  Simple_args_macro_definition_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Simple_args_macro_definition_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TICK_DEFINE();
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    Macro_argumentsContext *macro_arguments();
    Simple_macro_definition_body_in_macro_bodyContext *simple_macro_definition_body_in_macro_body();
    Identifier_in_macro_bodyContext *identifier_in_macro_body();
    antlr4::tree::TerminalNode *Escaped_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Simple_args_macro_definition_in_macro_bodyContext* simple_args_macro_definition_in_macro_body();

  class  Directive_in_macroContext : public antlr4::ParserRuleContext {
  public:
    Directive_in_macroContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Celldefine_directiveContext *celldefine_directive();
    Endcelldefine_directiveContext *endcelldefine_directive();
    Default_nettype_directiveContext *default_nettype_directive();
    Undef_directiveContext *undef_directive();
    Ifdef_directiveContext *ifdef_directive();
    Ifndef_directiveContext *ifndef_directive();
    Else_directiveContext *else_directive();
    Elsif_directiveContext *elsif_directive();
    Elseif_directiveContext *elseif_directive();
    Endif_directiveContext *endif_directive();
    Include_directiveContext *include_directive();
    Resetall_directiveContext *resetall_directive();
    Timescale_directiveContext *timescale_directive();
    Unconnected_drive_directiveContext *unconnected_drive_directive();
    Nounconnected_drive_directiveContext *nounconnected_drive_directive();
    Line_directiveContext *line_directive();
    Default_decay_time_directiveContext *default_decay_time_directive();
    Default_trireg_strenght_directiveContext *default_trireg_strenght_directive();
    Delay_mode_distributed_directiveContext *delay_mode_distributed_directive();
    Delay_mode_path_directiveContext *delay_mode_path_directive();
    Delay_mode_unit_directiveContext *delay_mode_unit_directive();
    Delay_mode_zero_directiveContext *delay_mode_zero_directive();
    Protect_directiveContext *protect_directive();
    Endprotect_directiveContext *endprotect_directive();
    Protected_directiveContext *protected_directive();
    Endprotected_directiveContext *endprotected_directive();
    Expand_vectornets_directiveContext *expand_vectornets_directive();
    Noexpand_vectornets_directiveContext *noexpand_vectornets_directive();
    Autoexpand_vectornets_directiveContext *autoexpand_vectornets_directive();
    Remove_gatename_directiveContext *remove_gatename_directive();
    Noremove_gatenames_directiveContext *noremove_gatenames_directive();
    Remove_netname_directiveContext *remove_netname_directive();
    Noremove_netnames_directiveContext *noremove_netnames_directive();
    Accelerate_directiveContext *accelerate_directive();
    Noaccelerate_directiveContext *noaccelerate_directive();
    Undefineall_directiveContext *undefineall_directive();
    Uselib_directiveContext *uselib_directive();
    Disable_portfaults_directiveContext *disable_portfaults_directive();
    Enable_portfaults_directiveContext *enable_portfaults_directive();
    Nosuppress_faults_directiveContext *nosuppress_faults_directive();
    Suppress_faults_directiveContext *suppress_faults_directive();
    Signed_directiveContext *signed_directive();
    Unsigned_directiveContext *unsigned_directive();
    Sv_file_directiveContext *sv_file_directive();
    Sv_line_directiveContext *sv_line_directive();
    Sv_packageContext *sv_package();
    EndpackageContext *endpackage();
    Simple_args_macro_definition_in_macro_bodyContext *simple_args_macro_definition_in_macro_body();
    Simple_no_args_macro_definition_in_macro_bodyContext *simple_no_args_macro_definition_in_macro_body();
    Pound_delayContext *pound_delay();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Directive_in_macroContext* directive_in_macro();

  class  Macro_argumentsContext : public antlr4::ParserRuleContext {
  public:
    Macro_argumentsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PARENS_OPEN();
    antlr4::tree::TerminalNode *PARENS_CLOSE();
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<antlr4::tree::TerminalNode *> EQUAL_OP();
    antlr4::tree::TerminalNode* EQUAL_OP(size_t i);
    std::vector<Default_valueContext *> default_value();
    Default_valueContext* default_value(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Macro_argumentsContext* macro_arguments();

  class  Escaped_macro_definition_bodyContext : public antlr4::ParserRuleContext {
  public:
    Escaped_macro_definition_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    Escaped_macro_definition_body_alt1Context *escaped_macro_definition_body_alt1();
    Escaped_macro_definition_body_alt2Context *escaped_macro_definition_body_alt2();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Escaped_macro_definition_bodyContext* escaped_macro_definition_body();

  class  Escaped_macro_definition_body_alt1Context : public antlr4::ParserRuleContext {
  public:
    Escaped_macro_definition_body_alt1Context(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<antlr4::tree::TerminalNode *> ESCAPED_CR();
    antlr4::tree::TerminalNode* ESCAPED_CR(size_t i);
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *EOF();
    std::vector<Unterminated_stringContext *> unterminated_string();
    Unterminated_stringContext* unterminated_string(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_identifier();
    antlr4::tree::TerminalNode* Macro_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_Escaped_identifier();
    antlr4::tree::TerminalNode* Macro_Escaped_identifier(size_t i);
    std::vector<Escaped_identifierContext *> escaped_identifier();
    Escaped_identifierContext* escaped_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<NumberContext *> number();
    NumberContext* number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TEXT_CR();
    antlr4::tree::TerminalNode* TEXT_CR(size_t i);
    std::vector<Pound_delayContext *> pound_delay();
    Pound_delayContext* pound_delay(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_OPEN();
    antlr4::tree::TerminalNode* PARENS_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_CLOSE();
    antlr4::tree::TerminalNode* PARENS_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    std::vector<antlr4::tree::TerminalNode *> EQUAL_OP();
    antlr4::tree::TerminalNode* EQUAL_OP(size_t i);
    std::vector<antlr4::tree::TerminalNode *> DOUBLE_QUOTE();
    antlr4::tree::TerminalNode* DOUBLE_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_VARIABLE();
    antlr4::tree::TerminalNode* TICK_VARIABLE(size_t i);
    std::vector<Directive_in_macroContext *> directive_in_macro();
    Directive_in_macroContext* directive_in_macro(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Fixed_point_number();
    antlr4::tree::TerminalNode* Fixed_point_number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> String();
    antlr4::tree::TerminalNode* String(size_t i);
    std::vector<CommentsContext *> comments();
    CommentsContext* comments(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_BACKSLASH_TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_BACKSLASH_TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_TICK();
    antlr4::tree::TerminalNode* TICK_TICK(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Special();
    antlr4::tree::TerminalNode* Special(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_OPEN();
    antlr4::tree::TerminalNode* CURLY_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_CLOSE();
    antlr4::tree::TerminalNode* CURLY_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_OPEN();
    antlr4::tree::TerminalNode* SQUARE_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_CLOSE();
    antlr4::tree::TerminalNode* SQUARE_CLOSE(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Escaped_macro_definition_body_alt1Context* escaped_macro_definition_body_alt1();

  class  Escaped_macro_definition_body_alt2Context : public antlr4::ParserRuleContext {
  public:
    Escaped_macro_definition_body_alt2Context(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *EOF();
    std::vector<Unterminated_stringContext *> unterminated_string();
    Unterminated_stringContext* unterminated_string(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_identifier();
    antlr4::tree::TerminalNode* Macro_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_Escaped_identifier();
    antlr4::tree::TerminalNode* Macro_Escaped_identifier(size_t i);
    std::vector<Escaped_identifierContext *> escaped_identifier();
    Escaped_identifierContext* escaped_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<NumberContext *> number();
    NumberContext* number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TEXT_CR();
    antlr4::tree::TerminalNode* TEXT_CR(size_t i);
    std::vector<Pound_delayContext *> pound_delay();
    Pound_delayContext* pound_delay(size_t i);
    std::vector<antlr4::tree::TerminalNode *> ESCAPED_CR();
    antlr4::tree::TerminalNode* ESCAPED_CR(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_OPEN();
    antlr4::tree::TerminalNode* PARENS_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_CLOSE();
    antlr4::tree::TerminalNode* PARENS_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    std::vector<antlr4::tree::TerminalNode *> EQUAL_OP();
    antlr4::tree::TerminalNode* EQUAL_OP(size_t i);
    std::vector<antlr4::tree::TerminalNode *> DOUBLE_QUOTE();
    antlr4::tree::TerminalNode* DOUBLE_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_VARIABLE();
    antlr4::tree::TerminalNode* TICK_VARIABLE(size_t i);
    std::vector<Directive_in_macroContext *> directive_in_macro();
    Directive_in_macroContext* directive_in_macro(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Fixed_point_number();
    antlr4::tree::TerminalNode* Fixed_point_number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> String();
    antlr4::tree::TerminalNode* String(size_t i);
    std::vector<CommentsContext *> comments();
    CommentsContext* comments(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_BACKSLASH_TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_BACKSLASH_TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_TICK();
    antlr4::tree::TerminalNode* TICK_TICK(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Special();
    antlr4::tree::TerminalNode* Special(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_OPEN();
    antlr4::tree::TerminalNode* CURLY_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_CLOSE();
    antlr4::tree::TerminalNode* CURLY_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_OPEN();
    antlr4::tree::TerminalNode* SQUARE_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_CLOSE();
    antlr4::tree::TerminalNode* SQUARE_CLOSE(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Escaped_macro_definition_body_alt2Context* escaped_macro_definition_body_alt2();

  class  Simple_macro_definition_bodyContext : public antlr4::ParserRuleContext {
  public:
    Simple_macro_definition_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Unterminated_stringContext *> unterminated_string();
    Unterminated_stringContext* unterminated_string(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_identifier();
    antlr4::tree::TerminalNode* Macro_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_Escaped_identifier();
    antlr4::tree::TerminalNode* Macro_Escaped_identifier(size_t i);
    std::vector<Escaped_identifierContext *> escaped_identifier();
    Escaped_identifierContext* escaped_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<NumberContext *> number();
    NumberContext* number(size_t i);
    std::vector<Pound_delayContext *> pound_delay();
    Pound_delayContext* pound_delay(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TEXT_CR();
    antlr4::tree::TerminalNode* TEXT_CR(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_OPEN();
    antlr4::tree::TerminalNode* PARENS_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_CLOSE();
    antlr4::tree::TerminalNode* PARENS_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    std::vector<antlr4::tree::TerminalNode *> EQUAL_OP();
    antlr4::tree::TerminalNode* EQUAL_OP(size_t i);
    std::vector<antlr4::tree::TerminalNode *> DOUBLE_QUOTE();
    antlr4::tree::TerminalNode* DOUBLE_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_VARIABLE();
    antlr4::tree::TerminalNode* TICK_VARIABLE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Fixed_point_number();
    antlr4::tree::TerminalNode* Fixed_point_number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> String();
    antlr4::tree::TerminalNode* String(size_t i);
    std::vector<CommentsContext *> comments();
    CommentsContext* comments(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_BACKSLASH_TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_BACKSLASH_TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_TICK();
    antlr4::tree::TerminalNode* TICK_TICK(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Special();
    antlr4::tree::TerminalNode* Special(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_OPEN();
    antlr4::tree::TerminalNode* CURLY_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_CLOSE();
    antlr4::tree::TerminalNode* CURLY_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_OPEN();
    antlr4::tree::TerminalNode* SQUARE_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_CLOSE();
    antlr4::tree::TerminalNode* SQUARE_CLOSE(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Simple_macro_definition_bodyContext* simple_macro_definition_body();

  class  Simple_macro_definition_body_in_macro_bodyContext : public antlr4::ParserRuleContext {
  public:
    Simple_macro_definition_body_in_macro_bodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<Unterminated_stringContext *> unterminated_string();
    Unterminated_stringContext* unterminated_string(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_identifier();
    antlr4::tree::TerminalNode* Macro_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Macro_Escaped_identifier();
    antlr4::tree::TerminalNode* Macro_Escaped_identifier(size_t i);
    std::vector<Escaped_identifierContext *> escaped_identifier();
    Escaped_identifierContext* escaped_identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<NumberContext *> number();
    NumberContext* number(size_t i);
    std::vector<Pound_delayContext *> pound_delay();
    Pound_delayContext* pound_delay(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TEXT_CR();
    antlr4::tree::TerminalNode* TEXT_CR(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_OPEN();
    antlr4::tree::TerminalNode* PARENS_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> PARENS_CLOSE();
    antlr4::tree::TerminalNode* PARENS_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    std::vector<antlr4::tree::TerminalNode *> EQUAL_OP();
    antlr4::tree::TerminalNode* EQUAL_OP(size_t i);
    std::vector<antlr4::tree::TerminalNode *> DOUBLE_QUOTE();
    antlr4::tree::TerminalNode* DOUBLE_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_VARIABLE();
    antlr4::tree::TerminalNode* TICK_VARIABLE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Fixed_point_number();
    antlr4::tree::TerminalNode* Fixed_point_number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> String();
    antlr4::tree::TerminalNode* String(size_t i);
    std::vector<CommentsContext *> comments();
    CommentsContext* comments(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_BACKSLASH_TICK_QUOTE();
    antlr4::tree::TerminalNode* TICK_BACKSLASH_TICK_QUOTE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TICK_TICK();
    antlr4::tree::TerminalNode* TICK_TICK(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Special();
    antlr4::tree::TerminalNode* Special(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_OPEN();
    antlr4::tree::TerminalNode* CURLY_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CURLY_CLOSE();
    antlr4::tree::TerminalNode* CURLY_CLOSE(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_OPEN();
    antlr4::tree::TerminalNode* SQUARE_OPEN(size_t i);
    std::vector<antlr4::tree::TerminalNode *> SQUARE_CLOSE();
    antlr4::tree::TerminalNode* SQUARE_CLOSE(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Simple_macro_definition_body_in_macro_bodyContext* simple_macro_definition_body_in_macro_body();

  class  Pragma_expressionContext : public antlr4::ParserRuleContext {
  public:
    Pragma_expressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Simple_identifier();
    NumberContext *number();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Fixed_point_number();
    antlr4::tree::TerminalNode *String();
    antlr4::tree::TerminalNode *Special();
    antlr4::tree::TerminalNode *CURLY_OPEN();
    antlr4::tree::TerminalNode *CURLY_CLOSE();
    antlr4::tree::TerminalNode *SQUARE_OPEN();
    antlr4::tree::TerminalNode *SQUARE_CLOSE();
    antlr4::tree::TerminalNode *PARENS_OPEN();
    antlr4::tree::TerminalNode *PARENS_CLOSE();
    antlr4::tree::TerminalNode *COMMA();
    antlr4::tree::TerminalNode *EQUAL_OP();
    antlr4::tree::TerminalNode *DOUBLE_QUOTE();
    antlr4::tree::TerminalNode *ANY();
    Escaped_identifierContext *escaped_identifier();
    Pound_delayContext *pound_delay();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Pragma_expressionContext* pragma_expression();

  class  Macro_argContext : public antlr4::ParserRuleContext {
  public:
    Macro_argContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Simple_identifier();
    NumberContext *number();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Fixed_point_number();
    antlr4::tree::TerminalNode *String();
    antlr4::tree::TerminalNode *Special();
    Paired_parensContext *paired_parens();
    antlr4::tree::TerminalNode *COMMA();
    antlr4::tree::TerminalNode *EQUAL_OP();
    antlr4::tree::TerminalNode *DOUBLE_QUOTE();
    Macro_instanceContext *macro_instance();
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *TEXT_CR();
    antlr4::tree::TerminalNode *ANY();
    Escaped_identifierContext *escaped_identifier();
    Simple_args_macro_definition_in_macro_bodyContext *simple_args_macro_definition_in_macro_body();
    Simple_no_args_macro_definition_in_macro_bodyContext *simple_no_args_macro_definition_in_macro_body();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Macro_argContext* macro_arg();

  class  Paired_parensContext : public antlr4::ParserRuleContext {
  public:
    Paired_parensContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *PARENS_OPEN();
    antlr4::tree::TerminalNode *PARENS_CLOSE();
    std::vector<antlr4::tree::TerminalNode *> Simple_identifier();
    antlr4::tree::TerminalNode* Simple_identifier(size_t i);
    std::vector<NumberContext *> number();
    NumberContext* number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Spaces();
    antlr4::tree::TerminalNode* Spaces(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Fixed_point_number();
    antlr4::tree::TerminalNode* Fixed_point_number(size_t i);
    std::vector<antlr4::tree::TerminalNode *> String();
    antlr4::tree::TerminalNode* String(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Special();
    antlr4::tree::TerminalNode* Special(size_t i);
    std::vector<antlr4::tree::TerminalNode *> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    std::vector<antlr4::tree::TerminalNode *> EQUAL_OP();
    antlr4::tree::TerminalNode* EQUAL_OP(size_t i);
    std::vector<antlr4::tree::TerminalNode *> DOUBLE_QUOTE();
    antlr4::tree::TerminalNode* DOUBLE_QUOTE(size_t i);
    std::vector<Macro_instanceContext *> macro_instance();
    Macro_instanceContext* macro_instance(size_t i);
    std::vector<antlr4::tree::TerminalNode *> TEXT_CR();
    antlr4::tree::TerminalNode* TEXT_CR(size_t i);
    std::vector<antlr4::tree::TerminalNode *> CR();
    antlr4::tree::TerminalNode* CR(size_t i);
    std::vector<antlr4::tree::TerminalNode *> ANY();
    antlr4::tree::TerminalNode* ANY(size_t i);
    std::vector<Paired_parensContext *> paired_parens();
    Paired_parensContext* paired_parens(size_t i);
    std::vector<Escaped_identifierContext *> escaped_identifier();
    Escaped_identifierContext* escaped_identifier(size_t i);
    antlr4::tree::TerminalNode *CURLY_OPEN();
    antlr4::tree::TerminalNode *CURLY_CLOSE();
    antlr4::tree::TerminalNode *SQUARE_OPEN();
    antlr4::tree::TerminalNode *SQUARE_CLOSE();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Paired_parensContext* paired_parens();

  class  Text_blobContext : public antlr4::ParserRuleContext {
  public:
    Text_blobContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Simple_identifier();
    NumberContext *number();
    antlr4::tree::TerminalNode *CR();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Fixed_point_number();
    antlr4::tree::TerminalNode *ESCAPED_CR();
    antlr4::tree::TerminalNode *String();
    antlr4::tree::TerminalNode *PARENS_OPEN();
    antlr4::tree::TerminalNode *PARENS_CLOSE();
    antlr4::tree::TerminalNode *COMMA();
    antlr4::tree::TerminalNode *EQUAL_OP();
    antlr4::tree::TerminalNode *DOUBLE_QUOTE();
    antlr4::tree::TerminalNode *Special();
    antlr4::tree::TerminalNode *CURLY_OPEN();
    antlr4::tree::TerminalNode *CURLY_CLOSE();
    antlr4::tree::TerminalNode *SQUARE_OPEN();
    antlr4::tree::TerminalNode *SQUARE_CLOSE();
    antlr4::tree::TerminalNode *TICK_TICK();
    antlr4::tree::TerminalNode *TICK_VARIABLE();
    antlr4::tree::TerminalNode *TIMESCALE();
    antlr4::tree::TerminalNode *ANY();
    Pound_delayContext *pound_delay();
    antlr4::tree::TerminalNode *TICK_QUOTE();
    antlr4::tree::TerminalNode *TICK_BACKSLASH_TICK_QUOTE();
    antlr4::tree::TerminalNode *TEXT_CR();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Text_blobContext* text_blob();

  class  StringContext : public antlr4::ParserRuleContext {
  public:
    StringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *String();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  StringContext* string();

  class  Escaped_identifierContext : public antlr4::ParserRuleContext {
  public:
    Escaped_identifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Escaped_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Escaped_identifierContext* escaped_identifier();

  class  Default_valueContext : public antlr4::ParserRuleContext {
  public:
    Default_valueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Simple_identifier();
    NumberContext *number();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Fixed_point_number();
    antlr4::tree::TerminalNode *String();
    antlr4::tree::TerminalNode *Special();
    antlr4::tree::TerminalNode *CURLY_OPEN();
    antlr4::tree::TerminalNode *CURLY_CLOSE();
    antlr4::tree::TerminalNode *SQUARE_OPEN();
    antlr4::tree::TerminalNode *SQUARE_CLOSE();
    antlr4::tree::TerminalNode *ANY();
    Escaped_identifierContext *escaped_identifier();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  Default_valueContext* default_value();

  class  String_blobContext : public antlr4::ParserRuleContext {
  public:
    String_blobContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *Simple_identifier();
    NumberContext *number();
    antlr4::tree::TerminalNode *Spaces();
    antlr4::tree::TerminalNode *Fixed_point_number();
    antlr4::tree::TerminalNode *ESCAPED_CR();
    antlr4::tree::TerminalNode *PARENS_OPEN();
    antlr4::tree::TerminalNode *PARENS_CLOSE();
    antlr4::tree::TerminalNode *COMMA();
    antlr4::tree::TerminalNode *EQUAL_OP();
    antlr4::tree::TerminalNode *DOUBLE_QUOTE();
    antlr4::tree::TerminalNode *Special();
    antlr4::tree::TerminalNode *CURLY_OPEN();
    antlr4::tree::TerminalNode *CURLY_CLOSE();
    antlr4::tree::TerminalNode *SQUARE_OPEN();
    antlr4::tree::TerminalNode *SQUARE_CLOSE();
    antlr4::tree::TerminalNode *ANY();
    Escaped_identifierContext *escaped_identifier();
    antlr4::tree::TerminalNode *TIMESCALE();
    Pound_delayContext *pound_delay();
    antlr4::tree::TerminalNode *TEXT_CR();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
   
  };

  String_blobContext* string_blob();


private:
  static std::vector<antlr4::dfa::DFA> _decisionToDFA;
  static antlr4::atn::PredictionContextCache _sharedContextCache;
  static std::vector<std::string> _ruleNames;
  static std::vector<std::string> _tokenNames;

  static std::vector<std::string> _literalNames;
  static std::vector<std::string> _symbolicNames;
  static antlr4::dfa::Vocabulary _vocabulary;
  static antlr4::atn::ATN _atn;
  static std::vector<uint16_t> _serializedATN;


  struct Initializer {
    Initializer();
  };
  static Initializer _init;
};