# This file is part of CoVeriTeam, a tool for on-demand composition of cooperative verification systems:
# https://gitlab.com/sosy-lab/software/coveriteam
#
# SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
#
# SPDX-License-Identifier: Apache-2.0

# Generated from CoVeriLang.g4 by ANTLR 4.11.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys

if sys.version_info[1] > 5:
    from typing import TextIO
else:
    from typing.io import TextIO


def serializedATN():
    return [
        4,
        1,
        49,
        360,
        2,
        0,
        7,
        0,
        2,
        1,
        7,
        1,
        2,
        2,
        7,
        2,
        2,
        3,
        7,
        3,
        2,
        4,
        7,
        4,
        2,
        5,
        7,
        5,
        2,
        6,
        7,
        6,
        2,
        7,
        7,
        7,
        2,
        8,
        7,
        8,
        2,
        9,
        7,
        9,
        2,
        10,
        7,
        10,
        2,
        11,
        7,
        11,
        2,
        12,
        7,
        12,
        2,
        13,
        7,
        13,
        2,
        14,
        7,
        14,
        2,
        15,
        7,
        15,
        2,
        16,
        7,
        16,
        2,
        17,
        7,
        17,
        2,
        18,
        7,
        18,
        2,
        19,
        7,
        19,
        2,
        20,
        7,
        20,
        2,
        21,
        7,
        21,
        2,
        22,
        7,
        22,
        2,
        23,
        7,
        23,
        2,
        24,
        7,
        24,
        1,
        0,
        5,
        0,
        52,
        8,
        0,
        10,
        0,
        12,
        0,
        55,
        9,
        0,
        1,
        0,
        1,
        0,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        3,
        1,
        63,
        8,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        2,
        1,
        2,
        1,
        2,
        5,
        2,
        73,
        8,
        2,
        10,
        2,
        12,
        2,
        76,
        9,
        2,
        1,
        3,
        1,
        3,
        1,
        3,
        5,
        3,
        81,
        8,
        3,
        10,
        3,
        12,
        3,
        84,
        9,
        3,
        1,
        4,
        1,
        4,
        1,
        4,
        1,
        4,
        1,
        4,
        3,
        4,
        91,
        8,
        4,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        6,
        1,
        6,
        1,
        6,
        1,
        6,
        1,
        6,
        3,
        6,
        102,
        8,
        6,
        1,
        6,
        1,
        6,
        1,
        7,
        1,
        7,
        1,
        7,
        1,
        7,
        1,
        7,
        3,
        7,
        111,
        8,
        7,
        1,
        7,
        1,
        7,
        1,
        8,
        1,
        8,
        1,
        8,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        11,
        1,
        11,
        1,
        11,
        5,
        11,
        131,
        8,
        11,
        10,
        11,
        12,
        11,
        134,
        9,
        11,
        1,
        12,
        1,
        12,
        1,
        12,
        1,
        12,
        1,
        12,
        3,
        12,
        141,
        8,
        12,
        3,
        12,
        143,
        8,
        12,
        1,
        13,
        1,
        13,
        1,
        13,
        1,
        13,
        1,
        13,
        1,
        13,
        3,
        13,
        151,
        8,
        13,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        3,
        14,
        159,
        8,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        3,
        14,
        166,
        8,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        4,
        14,
        175,
        8,
        14,
        11,
        14,
        12,
        14,
        176,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        3,
        14,
        188,
        8,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        4,
        14,
        204,
        8,
        14,
        11,
        14,
        12,
        14,
        205,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        5,
        14,
        215,
        8,
        14,
        10,
        14,
        12,
        14,
        218,
        9,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        3,
        14,
        230,
        8,
        14,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        3,
        15,
        274,
        8,
        15,
        1,
        15,
        1,
        15,
        3,
        15,
        278,
        8,
        15,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        3,
        16,
        286,
        8,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        3,
        16,
        294,
        8,
        16,
        1,
        17,
        1,
        17,
        1,
        18,
        1,
        18,
        1,
        19,
        1,
        19,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        3,
        20,
        327,
        8,
        20,
        1,
        20,
        1,
        20,
        1,
        20,
        5,
        20,
        332,
        8,
        20,
        10,
        20,
        12,
        20,
        335,
        9,
        20,
        1,
        21,
        1,
        21,
        1,
        21,
        5,
        21,
        340,
        8,
        21,
        10,
        21,
        12,
        21,
        343,
        9,
        21,
        1,
        22,
        1,
        22,
        1,
        23,
        1,
        23,
        1,
        23,
        1,
        23,
        1,
        23,
        1,
        23,
        1,
        23,
        3,
        23,
        354,
        8,
        23,
        1,
        24,
        1,
        24,
        1,
        24,
        1,
        24,
        1,
        24,
        1,
        53,
        1,
        40,
        25,
        0,
        2,
        4,
        6,
        8,
        10,
        12,
        14,
        16,
        18,
        20,
        22,
        24,
        26,
        28,
        30,
        32,
        34,
        36,
        38,
        40,
        42,
        44,
        46,
        48,
        0,
        2,
        1,
        0,
        39,
        40,
        2,
        0,
        30,
        31,
        39,
        39,
        390,
        0,
        53,
        1,
        0,
        0,
        0,
        2,
        58,
        1,
        0,
        0,
        0,
        4,
        74,
        1,
        0,
        0,
        0,
        6,
        77,
        1,
        0,
        0,
        0,
        8,
        90,
        1,
        0,
        0,
        0,
        10,
        92,
        1,
        0,
        0,
        0,
        12,
        96,
        1,
        0,
        0,
        0,
        14,
        105,
        1,
        0,
        0,
        0,
        16,
        114,
        1,
        0,
        0,
        0,
        18,
        117,
        1,
        0,
        0,
        0,
        20,
        123,
        1,
        0,
        0,
        0,
        22,
        127,
        1,
        0,
        0,
        0,
        24,
        135,
        1,
        0,
        0,
        0,
        26,
        150,
        1,
        0,
        0,
        0,
        28,
        229,
        1,
        0,
        0,
        0,
        30,
        277,
        1,
        0,
        0,
        0,
        32,
        293,
        1,
        0,
        0,
        0,
        34,
        295,
        1,
        0,
        0,
        0,
        36,
        297,
        1,
        0,
        0,
        0,
        38,
        299,
        1,
        0,
        0,
        0,
        40,
        326,
        1,
        0,
        0,
        0,
        42,
        336,
        1,
        0,
        0,
        0,
        44,
        344,
        1,
        0,
        0,
        0,
        46,
        353,
        1,
        0,
        0,
        0,
        48,
        355,
        1,
        0,
        0,
        0,
        50,
        52,
        3,
        2,
        1,
        0,
        51,
        50,
        1,
        0,
        0,
        0,
        52,
        55,
        1,
        0,
        0,
        0,
        53,
        54,
        1,
        0,
        0,
        0,
        53,
        51,
        1,
        0,
        0,
        0,
        54,
        56,
        1,
        0,
        0,
        0,
        55,
        53,
        1,
        0,
        0,
        0,
        56,
        57,
        3,
        4,
        2,
        0,
        57,
        1,
        1,
        0,
        0,
        0,
        58,
        59,
        5,
        1,
        0,
        0,
        59,
        60,
        5,
        39,
        0,
        0,
        60,
        62,
        5,
        2,
        0,
        0,
        61,
        63,
        3,
        6,
        3,
        0,
        62,
        61,
        1,
        0,
        0,
        0,
        62,
        63,
        1,
        0,
        0,
        0,
        63,
        64,
        1,
        0,
        0,
        0,
        64,
        65,
        5,
        3,
        0,
        0,
        65,
        66,
        5,
        4,
        0,
        0,
        66,
        67,
        3,
        4,
        2,
        0,
        67,
        68,
        5,
        5,
        0,
        0,
        68,
        3,
        1,
        0,
        0,
        0,
        69,
        70,
        3,
        8,
        4,
        0,
        70,
        71,
        5,
        48,
        0,
        0,
        71,
        73,
        1,
        0,
        0,
        0,
        72,
        69,
        1,
        0,
        0,
        0,
        73,
        76,
        1,
        0,
        0,
        0,
        74,
        72,
        1,
        0,
        0,
        0,
        74,
        75,
        1,
        0,
        0,
        0,
        75,
        5,
        1,
        0,
        0,
        0,
        76,
        74,
        1,
        0,
        0,
        0,
        77,
        82,
        5,
        39,
        0,
        0,
        78,
        79,
        5,
        6,
        0,
        0,
        79,
        81,
        5,
        39,
        0,
        0,
        80,
        78,
        1,
        0,
        0,
        0,
        81,
        84,
        1,
        0,
        0,
        0,
        82,
        80,
        1,
        0,
        0,
        0,
        82,
        83,
        1,
        0,
        0,
        0,
        83,
        7,
        1,
        0,
        0,
        0,
        84,
        82,
        1,
        0,
        0,
        0,
        85,
        91,
        3,
        10,
        5,
        0,
        86,
        91,
        3,
        14,
        7,
        0,
        87,
        91,
        3,
        16,
        8,
        0,
        88,
        91,
        3,
        12,
        6,
        0,
        89,
        91,
        3,
        18,
        9,
        0,
        90,
        85,
        1,
        0,
        0,
        0,
        90,
        86,
        1,
        0,
        0,
        0,
        90,
        87,
        1,
        0,
        0,
        0,
        90,
        88,
        1,
        0,
        0,
        0,
        90,
        89,
        1,
        0,
        0,
        0,
        91,
        9,
        1,
        0,
        0,
        0,
        92,
        93,
        5,
        39,
        0,
        0,
        93,
        94,
        5,
        7,
        0,
        0,
        94,
        95,
        3,
        26,
        13,
        0,
        95,
        11,
        1,
        0,
        0,
        0,
        96,
        101,
        5,
        8,
        0,
        0,
        97,
        102,
        3,
        28,
        14,
        0,
        98,
        102,
        3,
        32,
        16,
        0,
        99,
        102,
        5,
        40,
        0,
        0,
        100,
        102,
        5,
        39,
        0,
        0,
        101,
        97,
        1,
        0,
        0,
        0,
        101,
        98,
        1,
        0,
        0,
        0,
        101,
        99,
        1,
        0,
        0,
        0,
        101,
        100,
        1,
        0,
        0,
        0,
        102,
        103,
        1,
        0,
        0,
        0,
        103,
        104,
        5,
        3,
        0,
        0,
        104,
        13,
        1,
        0,
        0,
        0,
        105,
        106,
        5,
        9,
        0,
        0,
        106,
        107,
        3,
        28,
        14,
        0,
        107,
        110,
        5,
        6,
        0,
        0,
        108,
        111,
        5,
        39,
        0,
        0,
        109,
        111,
        3,
        20,
        10,
        0,
        110,
        108,
        1,
        0,
        0,
        0,
        110,
        109,
        1,
        0,
        0,
        0,
        111,
        112,
        1,
        0,
        0,
        0,
        112,
        113,
        5,
        3,
        0,
        0,
        113,
        15,
        1,
        0,
        0,
        0,
        114,
        115,
        5,
        10,
        0,
        0,
        115,
        116,
        5,
        39,
        0,
        0,
        116,
        17,
        1,
        0,
        0,
        0,
        117,
        118,
        5,
        11,
        0,
        0,
        118,
        119,
        5,
        39,
        0,
        0,
        119,
        120,
        5,
        6,
        0,
        0,
        120,
        121,
        5,
        40,
        0,
        0,
        121,
        122,
        5,
        3,
        0,
        0,
        122,
        19,
        1,
        0,
        0,
        0,
        123,
        124,
        5,
        4,
        0,
        0,
        124,
        125,
        3,
        22,
        11,
        0,
        125,
        126,
        5,
        5,
        0,
        0,
        126,
        21,
        1,
        0,
        0,
        0,
        127,
        132,
        3,
        24,
        12,
        0,
        128,
        129,
        5,
        6,
        0,
        0,
        129,
        131,
        3,
        24,
        12,
        0,
        130,
        128,
        1,
        0,
        0,
        0,
        131,
        134,
        1,
        0,
        0,
        0,
        132,
        130,
        1,
        0,
        0,
        0,
        132,
        133,
        1,
        0,
        0,
        0,
        133,
        23,
        1,
        0,
        0,
        0,
        134,
        132,
        1,
        0,
        0,
        0,
        135,
        142,
        3,
        46,
        23,
        0,
        136,
        140,
        5,
        12,
        0,
        0,
        137,
        141,
        3,
        32,
        16,
        0,
        138,
        141,
        3,
        34,
        17,
        0,
        139,
        141,
        3,
        48,
        24,
        0,
        140,
        137,
        1,
        0,
        0,
        0,
        140,
        138,
        1,
        0,
        0,
        0,
        140,
        139,
        1,
        0,
        0,
        0,
        141,
        143,
        1,
        0,
        0,
        0,
        142,
        136,
        1,
        0,
        0,
        0,
        142,
        143,
        1,
        0,
        0,
        0,
        143,
        25,
        1,
        0,
        0,
        0,
        144,
        151,
        3,
        40,
        20,
        0,
        145,
        151,
        3,
        32,
        16,
        0,
        146,
        151,
        3,
        20,
        10,
        0,
        147,
        151,
        3,
        28,
        14,
        0,
        148,
        151,
        5,
        40,
        0,
        0,
        149,
        151,
        3,
        14,
        7,
        0,
        150,
        144,
        1,
        0,
        0,
        0,
        150,
        145,
        1,
        0,
        0,
        0,
        150,
        146,
        1,
        0,
        0,
        0,
        150,
        147,
        1,
        0,
        0,
        0,
        150,
        148,
        1,
        0,
        0,
        0,
        150,
        149,
        1,
        0,
        0,
        0,
        151,
        27,
        1,
        0,
        0,
        0,
        152,
        153,
        5,
        13,
        0,
        0,
        153,
        154,
        3,
        38,
        19,
        0,
        154,
        155,
        5,
        6,
        0,
        0,
        155,
        158,
        7,
        0,
        0,
        0,
        156,
        157,
        5,
        6,
        0,
        0,
        157,
        159,
        7,
        0,
        0,
        0,
        158,
        156,
        1,
        0,
        0,
        0,
        158,
        159,
        1,
        0,
        0,
        0,
        159,
        160,
        1,
        0,
        0,
        0,
        160,
        161,
        5,
        3,
        0,
        0,
        161,
        230,
        1,
        0,
        0,
        0,
        162,
        163,
        5,
        39,
        0,
        0,
        163,
        165,
        5,
        2,
        0,
        0,
        164,
        166,
        3,
        6,
        3,
        0,
        165,
        164,
        1,
        0,
        0,
        0,
        165,
        166,
        1,
        0,
        0,
        0,
        166,
        167,
        1,
        0,
        0,
        0,
        167,
        230,
        5,
        3,
        0,
        0,
        168,
        230,
        3,
        30,
        15,
        0,
        169,
        170,
        5,
        14,
        0,
        0,
        170,
        171,
        5,
        2,
        0,
        0,
        171,
        174,
        3,
        28,
        14,
        0,
        172,
        173,
        5,
        6,
        0,
        0,
        173,
        175,
        3,
        28,
        14,
        0,
        174,
        172,
        1,
        0,
        0,
        0,
        175,
        176,
        1,
        0,
        0,
        0,
        176,
        174,
        1,
        0,
        0,
        0,
        176,
        177,
        1,
        0,
        0,
        0,
        177,
        178,
        1,
        0,
        0,
        0,
        178,
        179,
        5,
        3,
        0,
        0,
        179,
        230,
        1,
        0,
        0,
        0,
        180,
        181,
        5,
        15,
        0,
        0,
        181,
        182,
        5,
        2,
        0,
        0,
        182,
        183,
        3,
        40,
        20,
        0,
        183,
        184,
        5,
        6,
        0,
        0,
        184,
        187,
        3,
        28,
        14,
        0,
        185,
        186,
        5,
        6,
        0,
        0,
        186,
        188,
        3,
        28,
        14,
        0,
        187,
        185,
        1,
        0,
        0,
        0,
        187,
        188,
        1,
        0,
        0,
        0,
        188,
        189,
        1,
        0,
        0,
        0,
        189,
        190,
        5,
        3,
        0,
        0,
        190,
        230,
        1,
        0,
        0,
        0,
        191,
        192,
        5,
        16,
        0,
        0,
        192,
        193,
        5,
        2,
        0,
        0,
        193,
        194,
        3,
        40,
        20,
        0,
        194,
        195,
        5,
        6,
        0,
        0,
        195,
        196,
        3,
        28,
        14,
        0,
        196,
        197,
        5,
        3,
        0,
        0,
        197,
        230,
        1,
        0,
        0,
        0,
        198,
        199,
        5,
        17,
        0,
        0,
        199,
        200,
        5,
        2,
        0,
        0,
        200,
        203,
        3,
        28,
        14,
        0,
        201,
        202,
        5,
        6,
        0,
        0,
        202,
        204,
        3,
        28,
        14,
        0,
        203,
        201,
        1,
        0,
        0,
        0,
        204,
        205,
        1,
        0,
        0,
        0,
        205,
        203,
        1,
        0,
        0,
        0,
        205,
        206,
        1,
        0,
        0,
        0,
        206,
        207,
        1,
        0,
        0,
        0,
        207,
        208,
        5,
        3,
        0,
        0,
        208,
        230,
        1,
        0,
        0,
        0,
        209,
        210,
        5,
        18,
        0,
        0,
        210,
        211,
        5,
        2,
        0,
        0,
        211,
        216,
        3,
        28,
        14,
        0,
        212,
        213,
        5,
        6,
        0,
        0,
        213,
        215,
        3,
        28,
        14,
        0,
        214,
        212,
        1,
        0,
        0,
        0,
        215,
        218,
        1,
        0,
        0,
        0,
        216,
        214,
        1,
        0,
        0,
        0,
        216,
        217,
        1,
        0,
        0,
        0,
        217,
        219,
        1,
        0,
        0,
        0,
        218,
        216,
        1,
        0,
        0,
        0,
        219,
        220,
        5,
        6,
        0,
        0,
        220,
        221,
        3,
        40,
        20,
        0,
        221,
        222,
        1,
        0,
        0,
        0,
        222,
        223,
        5,
        3,
        0,
        0,
        223,
        230,
        1,
        0,
        0,
        0,
        224,
        230,
        5,
        39,
        0,
        0,
        225,
        226,
        5,
        2,
        0,
        0,
        226,
        227,
        3,
        28,
        14,
        0,
        227,
        228,
        5,
        3,
        0,
        0,
        228,
        230,
        1,
        0,
        0,
        0,
        229,
        152,
        1,
        0,
        0,
        0,
        229,
        162,
        1,
        0,
        0,
        0,
        229,
        168,
        1,
        0,
        0,
        0,
        229,
        169,
        1,
        0,
        0,
        0,
        229,
        180,
        1,
        0,
        0,
        0,
        229,
        191,
        1,
        0,
        0,
        0,
        229,
        198,
        1,
        0,
        0,
        0,
        229,
        209,
        1,
        0,
        0,
        0,
        229,
        224,
        1,
        0,
        0,
        0,
        229,
        225,
        1,
        0,
        0,
        0,
        230,
        29,
        1,
        0,
        0,
        0,
        231,
        232,
        5,
        19,
        0,
        0,
        232,
        233,
        5,
        2,
        0,
        0,
        233,
        234,
        3,
        34,
        17,
        0,
        234,
        235,
        5,
        6,
        0,
        0,
        235,
        236,
        3,
        20,
        10,
        0,
        236,
        237,
        5,
        6,
        0,
        0,
        237,
        238,
        3,
        48,
        24,
        0,
        238,
        239,
        5,
        3,
        0,
        0,
        239,
        278,
        1,
        0,
        0,
        0,
        240,
        241,
        5,
        20,
        0,
        0,
        241,
        242,
        5,
        2,
        0,
        0,
        242,
        243,
        3,
        48,
        24,
        0,
        243,
        244,
        5,
        6,
        0,
        0,
        244,
        245,
        5,
        39,
        0,
        0,
        245,
        246,
        5,
        3,
        0,
        0,
        246,
        278,
        1,
        0,
        0,
        0,
        247,
        248,
        5,
        21,
        0,
        0,
        248,
        249,
        5,
        2,
        0,
        0,
        249,
        250,
        3,
        34,
        17,
        0,
        250,
        251,
        5,
        6,
        0,
        0,
        251,
        252,
        3,
        20,
        10,
        0,
        252,
        253,
        5,
        6,
        0,
        0,
        253,
        254,
        3,
        48,
        24,
        0,
        254,
        255,
        5,
        3,
        0,
        0,
        255,
        278,
        1,
        0,
        0,
        0,
        256,
        257,
        5,
        22,
        0,
        0,
        257,
        258,
        5,
        2,
        0,
        0,
        258,
        259,
        3,
        20,
        10,
        0,
        259,
        260,
        5,
        3,
        0,
        0,
        260,
        278,
        1,
        0,
        0,
        0,
        261,
        262,
        5,
        23,
        0,
        0,
        262,
        263,
        5,
        2,
        0,
        0,
        263,
        264,
        3,
        20,
        10,
        0,
        264,
        265,
        5,
        3,
        0,
        0,
        265,
        278,
        1,
        0,
        0,
        0,
        266,
        278,
        5,
        24,
        0,
        0,
        267,
        278,
        5,
        25,
        0,
        0,
        268,
        278,
        5,
        26,
        0,
        0,
        269,
        270,
        5,
        27,
        0,
        0,
        270,
        273,
        5,
        2,
        0,
        0,
        271,
        274,
        3,
        28,
        14,
        0,
        272,
        274,
        3,
        20,
        10,
        0,
        273,
        271,
        1,
        0,
        0,
        0,
        273,
        272,
        1,
        0,
        0,
        0,
        274,
        275,
        1,
        0,
        0,
        0,
        275,
        276,
        5,
        3,
        0,
        0,
        276,
        278,
        1,
        0,
        0,
        0,
        277,
        231,
        1,
        0,
        0,
        0,
        277,
        240,
        1,
        0,
        0,
        0,
        277,
        247,
        1,
        0,
        0,
        0,
        277,
        256,
        1,
        0,
        0,
        0,
        277,
        261,
        1,
        0,
        0,
        0,
        277,
        266,
        1,
        0,
        0,
        0,
        277,
        267,
        1,
        0,
        0,
        0,
        277,
        268,
        1,
        0,
        0,
        0,
        277,
        269,
        1,
        0,
        0,
        0,
        278,
        31,
        1,
        0,
        0,
        0,
        279,
        280,
        5,
        28,
        0,
        0,
        280,
        281,
        3,
        34,
        17,
        0,
        281,
        282,
        5,
        6,
        0,
        0,
        282,
        285,
        7,
        0,
        0,
        0,
        283,
        284,
        5,
        6,
        0,
        0,
        284,
        286,
        3,
        36,
        18,
        0,
        285,
        283,
        1,
        0,
        0,
        0,
        285,
        286,
        1,
        0,
        0,
        0,
        286,
        287,
        1,
        0,
        0,
        0,
        287,
        288,
        5,
        3,
        0,
        0,
        288,
        294,
        1,
        0,
        0,
        0,
        289,
        294,
        5,
        39,
        0,
        0,
        290,
        291,
        5,
        39,
        0,
        0,
        291,
        292,
        5,
        29,
        0,
        0,
        292,
        294,
        5,
        39,
        0,
        0,
        293,
        279,
        1,
        0,
        0,
        0,
        293,
        289,
        1,
        0,
        0,
        0,
        293,
        290,
        1,
        0,
        0,
        0,
        294,
        33,
        1,
        0,
        0,
        0,
        295,
        296,
        5,
        41,
        0,
        0,
        296,
        35,
        1,
        0,
        0,
        0,
        297,
        298,
        7,
        1,
        0,
        0,
        298,
        37,
        1,
        0,
        0,
        0,
        299,
        300,
        5,
        41,
        0,
        0,
        300,
        39,
        1,
        0,
        0,
        0,
        301,
        302,
        6,
        20,
        -1,
        0,
        302,
        303,
        5,
        32,
        0,
        0,
        303,
        327,
        3,
        40,
        20,
        6,
        304,
        305,
        5,
        33,
        0,
        0,
        305,
        306,
        5,
        2,
        0,
        0,
        306,
        307,
        5,
        39,
        0,
        0,
        307,
        308,
        5,
        6,
        0,
        0,
        308,
        309,
        3,
        34,
        17,
        0,
        309,
        310,
        5,
        3,
        0,
        0,
        310,
        327,
        1,
        0,
        0,
        0,
        311,
        312,
        5,
        34,
        0,
        0,
        312,
        313,
        5,
        2,
        0,
        0,
        313,
        314,
        5,
        39,
        0,
        0,
        314,
        315,
        5,
        6,
        0,
        0,
        315,
        316,
        5,
        4,
        0,
        0,
        316,
        317,
        3,
        42,
        21,
        0,
        317,
        318,
        5,
        5,
        0,
        0,
        318,
        319,
        5,
        3,
        0,
        0,
        319,
        327,
        1,
        0,
        0,
        0,
        320,
        327,
        5,
        39,
        0,
        0,
        321,
        327,
        3,
        48,
        24,
        0,
        322,
        323,
        5,
        2,
        0,
        0,
        323,
        324,
        3,
        40,
        20,
        0,
        324,
        325,
        5,
        3,
        0,
        0,
        325,
        327,
        1,
        0,
        0,
        0,
        326,
        301,
        1,
        0,
        0,
        0,
        326,
        304,
        1,
        0,
        0,
        0,
        326,
        311,
        1,
        0,
        0,
        0,
        326,
        320,
        1,
        0,
        0,
        0,
        326,
        321,
        1,
        0,
        0,
        0,
        326,
        322,
        1,
        0,
        0,
        0,
        327,
        333,
        1,
        0,
        0,
        0,
        328,
        329,
        10,
        7,
        0,
        0,
        329,
        330,
        5,
        38,
        0,
        0,
        330,
        332,
        3,
        40,
        20,
        8,
        331,
        328,
        1,
        0,
        0,
        0,
        332,
        335,
        1,
        0,
        0,
        0,
        333,
        331,
        1,
        0,
        0,
        0,
        333,
        334,
        1,
        0,
        0,
        0,
        334,
        41,
        1,
        0,
        0,
        0,
        335,
        333,
        1,
        0,
        0,
        0,
        336,
        341,
        5,
        37,
        0,
        0,
        337,
        338,
        5,
        6,
        0,
        0,
        338,
        340,
        5,
        37,
        0,
        0,
        339,
        337,
        1,
        0,
        0,
        0,
        340,
        343,
        1,
        0,
        0,
        0,
        341,
        339,
        1,
        0,
        0,
        0,
        341,
        342,
        1,
        0,
        0,
        0,
        342,
        43,
        1,
        0,
        0,
        0,
        343,
        341,
        1,
        0,
        0,
        0,
        344,
        345,
        5,
        35,
        0,
        0,
        345,
        45,
        1,
        0,
        0,
        0,
        346,
        354,
        3,
        48,
        24,
        0,
        347,
        348,
        5,
        2,
        0,
        0,
        348,
        349,
        3,
        48,
        24,
        0,
        349,
        350,
        5,
        6,
        0,
        0,
        350,
        351,
        5,
        41,
        0,
        0,
        351,
        352,
        5,
        3,
        0,
        0,
        352,
        354,
        1,
        0,
        0,
        0,
        353,
        346,
        1,
        0,
        0,
        0,
        353,
        347,
        1,
        0,
        0,
        0,
        354,
        47,
        1,
        0,
        0,
        0,
        355,
        356,
        5,
        36,
        0,
        0,
        356,
        357,
        5,
        39,
        0,
        0,
        357,
        358,
        5,
        36,
        0,
        0,
        358,
        49,
        1,
        0,
        0,
        0,
        26,
        53,
        62,
        74,
        82,
        90,
        101,
        110,
        132,
        140,
        142,
        150,
        158,
        165,
        176,
        187,
        205,
        216,
        229,
        273,
        277,
        285,
        293,
        326,
        333,
        341,
        353,
    ]


class CoVeriLangParser(Parser):
    grammarFileName = "CoVeriLang.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [
        "<INVALID>",
        "'fun'",
        "'('",
        "')'",
        "'{'",
        "'}'",
        "','",
        "'='",
        "'print('",
        "'execute('",
        "'return'",
        "'set_actor_name('",
        "':'",
        "'ActorFactory.create('",
        "'SEQUENCE'",
        "'ITE'",
        "'REPEAT'",
        "'PARALLEL'",
        "'PARALLEL_PORTFOLIO'",
        "'Joiner'",
        "'Setter'",
        "'Comparator'",
        "'Copy'",
        "'Rename'",
        "'TestSpecToSpec()'",
        "'SpecToTestSpec()'",
        "'ClassificationToActorDefinition()'",
        "'Identity'",
        "'ArtifactFactory.create('",
        "'.'",
        "'ILP32'",
        "'LP64'",
        "'NOT'",
        "'INSTANCEOF'",
        "'ELEMENTOF'",
        "'TODO---'",
        "'''",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "';'",
    ]

    symbolicNames = [
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "VERDICT",
        "BIN_OP",
        "ID",
        "STRING",
        "TYPE_NAME",
        "LETTER",
        "LOWER_CASE",
        "UPPER_CASE",
        "DIGIT",
        "NEWLINE",
        "WS",
        "DELIMITER",
        "COMMENT",
    ]

    RULE_program = 0
    RULE_fun_decl = 1
    RULE_stmt_block = 2
    RULE_id_list = 3
    RULE_stmt = 4
    RULE_spec_stmt = 5
    RULE_print_stmt = 6
    RULE_exec_stmt = 7
    RULE_return_stmt = 8
    RULE_set_actor_name_stmt = 9
    RULE_arg_map = 10
    RULE_map_item_list = 11
    RULE_map_item = 12
    RULE_assignable = 13
    RULE_actor = 14
    RULE_utility_actor = 15
    RULE_artifact = 16
    RULE_artifact_type = 17
    RULE_data_model = 18
    RULE_actor_type = 19
    RULE_exp = 20
    RULE_verdict_list = 21
    RULE_tc_exp = 22
    RULE_quoted_ID_with_maybe_type = 23
    RULE_quoted_ID = 24

    ruleNames = [
        "program",
        "fun_decl",
        "stmt_block",
        "id_list",
        "stmt",
        "spec_stmt",
        "print_stmt",
        "exec_stmt",
        "return_stmt",
        "set_actor_name_stmt",
        "arg_map",
        "map_item_list",
        "map_item",
        "assignable",
        "actor",
        "utility_actor",
        "artifact",
        "artifact_type",
        "data_model",
        "actor_type",
        "exp",
        "verdict_list",
        "tc_exp",
        "quoted_ID_with_maybe_type",
        "quoted_ID",
    ]

    EOF = Token.EOF
    T__0 = 1
    T__1 = 2
    T__2 = 3
    T__3 = 4
    T__4 = 5
    T__5 = 6
    T__6 = 7
    T__7 = 8
    T__8 = 9
    T__9 = 10
    T__10 = 11
    T__11 = 12
    T__12 = 13
    T__13 = 14
    T__14 = 15
    T__15 = 16
    T__16 = 17
    T__17 = 18
    T__18 = 19
    T__19 = 20
    T__20 = 21
    T__21 = 22
    T__22 = 23
    T__23 = 24
    T__24 = 25
    T__25 = 26
    T__26 = 27
    T__27 = 28
    T__28 = 29
    T__29 = 30
    T__30 = 31
    T__31 = 32
    T__32 = 33
    T__33 = 34
    T__34 = 35
    T__35 = 36
    VERDICT = 37
    BIN_OP = 38
    ID = 39
    STRING = 40
    TYPE_NAME = 41
    LETTER = 42
    LOWER_CASE = 43
    UPPER_CASE = 44
    DIGIT = 45
    NEWLINE = 46
    WS = 47
    DELIMITER = 48
    COMMENT = 49

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

    class ProgramContext(ParserRuleContext):
        __slots__ = "parser"

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

        def stmt_block(self):
            return self.getTypedRuleContext(CoVeriLangParser.Stmt_blockContext, 0)

        def fun_decl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.Fun_declContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.Fun_declContext, i)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_program

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitProgram"):
                return visitor.visitProgram(self)
            else:
                return visitor.visitChildren(self)

    def program(self):
        localctx = CoVeriLangParser.ProgramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_program)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 53
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)
            while _alt != 1 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1 + 1:
                    self.state = 50
                    self.fun_decl()
                self.state = 55
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)

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

    class Fun_declContext(ParserRuleContext):
        __slots__ = "parser"

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

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def stmt_block(self):
            return self.getTypedRuleContext(CoVeriLangParser.Stmt_blockContext, 0)

        def id_list(self):
            return self.getTypedRuleContext(CoVeriLangParser.Id_listContext, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_fun_decl

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFun_decl"):
                return visitor.visitFun_decl(self)
            else:
                return visitor.visitChildren(self)

    def fun_decl(self):
        localctx = CoVeriLangParser.Fun_declContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_fun_decl)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 58
            self.match(CoVeriLangParser.T__0)
            self.state = 59
            self.match(CoVeriLangParser.ID)
            self.state = 60
            self.match(CoVeriLangParser.T__1)
            self.state = 62
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == 39:
                self.state = 61
                self.id_list()

            self.state = 64
            self.match(CoVeriLangParser.T__2)
            self.state = 65
            self.match(CoVeriLangParser.T__3)
            self.state = 66
            self.stmt_block()
            self.state = 67
            self.match(CoVeriLangParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Stmt_blockContext(ParserRuleContext):
        __slots__ = "parser"

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

        def stmt(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.StmtContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.StmtContext, i)

        def DELIMITER(self, i: int = None):
            if i is None:
                return self.getTokens(CoVeriLangParser.DELIMITER)
            else:
                return self.getToken(CoVeriLangParser.DELIMITER, i)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_stmt_block

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStmt_block"):
                return visitor.visitStmt_block(self)
            else:
                return visitor.visitChildren(self)

    def stmt_block(self):
        localctx = CoVeriLangParser.Stmt_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_stmt_block)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 74
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((_la) & ~0x3F) == 0 and ((1 << _la) & 549755817728) != 0:
                self.state = 69
                self.stmt()
                self.state = 70
                self.match(CoVeriLangParser.DELIMITER)
                self.state = 76
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class Id_listContext(ParserRuleContext):
        __slots__ = "parser"

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

        def ID(self, i: int = None):
            if i is None:
                return self.getTokens(CoVeriLangParser.ID)
            else:
                return self.getToken(CoVeriLangParser.ID, i)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_id_list

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitId_list"):
                return visitor.visitId_list(self)
            else:
                return visitor.visitChildren(self)

    def id_list(self):
        localctx = CoVeriLangParser.Id_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_id_list)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 77
            self.match(CoVeriLangParser.ID)
            self.state = 82
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == 6:
                self.state = 78
                self.match(CoVeriLangParser.T__5)
                self.state = 79
                self.match(CoVeriLangParser.ID)
                self.state = 84
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class StmtContext(ParserRuleContext):
        __slots__ = "parser"

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

        def spec_stmt(self):
            return self.getTypedRuleContext(CoVeriLangParser.Spec_stmtContext, 0)

        def exec_stmt(self):
            return self.getTypedRuleContext(CoVeriLangParser.Exec_stmtContext, 0)

        def return_stmt(self):
            return self.getTypedRuleContext(CoVeriLangParser.Return_stmtContext, 0)

        def print_stmt(self):
            return self.getTypedRuleContext(CoVeriLangParser.Print_stmtContext, 0)

        def set_actor_name_stmt(self):
            return self.getTypedRuleContext(
                CoVeriLangParser.Set_actor_name_stmtContext, 0
            )

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_stmt

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStmt"):
                return visitor.visitStmt(self)
            else:
                return visitor.visitChildren(self)

    def stmt(self):
        localctx = CoVeriLangParser.StmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_stmt)
        try:
            self.state = 90
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [39]:
                self.enterOuterAlt(localctx, 1)
                self.state = 85
                self.spec_stmt()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 86
                self.exec_stmt()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 3)
                self.state = 87
                self.return_stmt()
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 4)
                self.state = 88
                self.print_stmt()
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 5)
                self.state = 89
                self.set_actor_name_stmt()
                pass
            else:
                raise NoViableAltException(self)

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

    class Spec_stmtContext(ParserRuleContext):
        __slots__ = "parser"

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

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def assignable(self):
            return self.getTypedRuleContext(CoVeriLangParser.AssignableContext, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_spec_stmt

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSpec_stmt"):
                return visitor.visitSpec_stmt(self)
            else:
                return visitor.visitChildren(self)

    def spec_stmt(self):
        localctx = CoVeriLangParser.Spec_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_spec_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 92
            self.match(CoVeriLangParser.ID)
            self.state = 93
            self.match(CoVeriLangParser.T__6)
            self.state = 94
            self.assignable()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Print_stmtContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_print_stmt

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class PrintActorContext(Print_stmtContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Print_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.ActorContext, 0)

        def artifact(self):
            return self.getTypedRuleContext(CoVeriLangParser.ArtifactContext, 0)

        def STRING(self):
            return self.getToken(CoVeriLangParser.STRING, 0)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPrintActor"):
                return visitor.visitPrintActor(self)
            else:
                return visitor.visitChildren(self)

    def print_stmt(self):
        localctx = CoVeriLangParser.Print_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_print_stmt)
        try:
            localctx = CoVeriLangParser.PrintActorContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 96
            self.match(CoVeriLangParser.T__7)
            self.state = 101
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 5, self._ctx)
            if la_ == 1:
                self.state = 97
                self.actor()
                pass

            elif la_ == 2:
                self.state = 98
                self.artifact()
                pass

            elif la_ == 3:
                self.state = 99
                self.match(CoVeriLangParser.STRING)
                pass

            elif la_ == 4:
                self.state = 100
                self.match(CoVeriLangParser.ID)
                pass

            self.state = 103
            self.match(CoVeriLangParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Exec_stmtContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_exec_stmt

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class ExecuteActorContext(Exec_stmtContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Exec_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.ActorContext, 0)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExecuteActor"):
                return visitor.visitExecuteActor(self)
            else:
                return visitor.visitChildren(self)

    def exec_stmt(self):
        localctx = CoVeriLangParser.Exec_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_exec_stmt)
        try:
            localctx = CoVeriLangParser.ExecuteActorContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 105
            self.match(CoVeriLangParser.T__8)
            self.state = 106
            self.actor()
            self.state = 107
            self.match(CoVeriLangParser.T__5)
            self.state = 110
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [39]:
                self.state = 108
                self.match(CoVeriLangParser.ID)
                pass
            elif token in [4]:
                self.state = 109
                self.arg_map()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 112
            self.match(CoVeriLangParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Return_stmtContext(ParserRuleContext):
        __slots__ = "parser"

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

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_return_stmt

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitReturn_stmt"):
                return visitor.visitReturn_stmt(self)
            else:
                return visitor.visitChildren(self)

    def return_stmt(self):
        localctx = CoVeriLangParser.Return_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_return_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 114
            self.match(CoVeriLangParser.T__9)
            self.state = 115
            self.match(CoVeriLangParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Set_actor_name_stmtContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_set_actor_name_stmt

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class SetActorNameContext(Set_actor_name_stmtContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Set_actor_name_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def STRING(self):
            return self.getToken(CoVeriLangParser.STRING, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSetActorName"):
                return visitor.visitSetActorName(self)
            else:
                return visitor.visitChildren(self)

    def set_actor_name_stmt(self):
        localctx = CoVeriLangParser.Set_actor_name_stmtContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 18, self.RULE_set_actor_name_stmt)
        try:
            localctx = CoVeriLangParser.SetActorNameContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 117
            self.match(CoVeriLangParser.T__10)
            self.state = 118
            self.match(CoVeriLangParser.ID)
            self.state = 119
            self.match(CoVeriLangParser.T__5)
            self.state = 120
            self.match(CoVeriLangParser.STRING)
            self.state = 121
            self.match(CoVeriLangParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Arg_mapContext(ParserRuleContext):
        __slots__ = "parser"

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

        def map_item_list(self):
            return self.getTypedRuleContext(CoVeriLangParser.Map_item_listContext, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_arg_map

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArg_map"):
                return visitor.visitArg_map(self)
            else:
                return visitor.visitChildren(self)

    def arg_map(self):
        localctx = CoVeriLangParser.Arg_mapContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_arg_map)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 123
            self.match(CoVeriLangParser.T__3)
            self.state = 124
            self.map_item_list()
            self.state = 125
            self.match(CoVeriLangParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Map_item_listContext(ParserRuleContext):
        __slots__ = "parser"

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

        def map_item(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.Map_itemContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.Map_itemContext, i)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_map_item_list

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMap_item_list"):
                return visitor.visitMap_item_list(self)
            else:
                return visitor.visitChildren(self)

    def map_item_list(self):
        localctx = CoVeriLangParser.Map_item_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_map_item_list)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 127
            self.map_item()
            self.state = 132
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == 6:
                self.state = 128
                self.match(CoVeriLangParser.T__5)
                self.state = 129
                self.map_item()
                self.state = 134
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class Map_itemContext(ParserRuleContext):
        __slots__ = "parser"

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

        def quoted_ID_with_maybe_type(self):
            return self.getTypedRuleContext(
                CoVeriLangParser.Quoted_ID_with_maybe_typeContext, 0
            )

        def artifact(self):
            return self.getTypedRuleContext(CoVeriLangParser.ArtifactContext, 0)

        def artifact_type(self):
            return self.getTypedRuleContext(CoVeriLangParser.Artifact_typeContext, 0)

        def quoted_ID(self):
            return self.getTypedRuleContext(CoVeriLangParser.Quoted_IDContext, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_map_item

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMap_item"):
                return visitor.visitMap_item(self)
            else:
                return visitor.visitChildren(self)

    def map_item(self):
        localctx = CoVeriLangParser.Map_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_map_item)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 135
            self.quoted_ID_with_maybe_type()
            self.state = 142
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == 12:
                self.state = 136
                self.match(CoVeriLangParser.T__11)
                self.state = 140
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [28, 39]:
                    self.state = 137
                    self.artifact()
                    pass
                elif token in [41]:
                    self.state = 138
                    self.artifact_type()
                    pass
                elif token in [36]:
                    self.state = 139
                    self.quoted_ID()
                    pass
                else:
                    raise NoViableAltException(self)

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

    class AssignableContext(ParserRuleContext):
        __slots__ = "parser"

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

        def exp(self):
            return self.getTypedRuleContext(CoVeriLangParser.ExpContext, 0)

        def artifact(self):
            return self.getTypedRuleContext(CoVeriLangParser.ArtifactContext, 0)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

        def actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.ActorContext, 0)

        def STRING(self):
            return self.getToken(CoVeriLangParser.STRING, 0)

        def exec_stmt(self):
            return self.getTypedRuleContext(CoVeriLangParser.Exec_stmtContext, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_assignable

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAssignable"):
                return visitor.visitAssignable(self)
            else:
                return visitor.visitChildren(self)

    def assignable(self):
        localctx = CoVeriLangParser.AssignableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_assignable)
        try:
            self.state = 150
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 10, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 144
                self.exp(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 145
                self.artifact()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 146
                self.arg_map()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 147
                self.actor()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 148
                self.match(CoVeriLangParser.STRING)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 149
                self.exec_stmt()
                pass

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

    class ActorContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_actor

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class UtilityContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def utility_actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.Utility_actorContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitUtility"):
                return visitor.visitUtility(self)
            else:
                return visitor.visitChildren(self)

    class ParenthesisContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.ActorContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParenthesis"):
                return visitor.visitParenthesis(self)
            else:
                return visitor.visitChildren(self)

    class FunCallContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def id_list(self):
            return self.getTypedRuleContext(CoVeriLangParser.Id_listContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFunCall"):
                return visitor.visitFunCall(self)
            else:
                return visitor.visitChildren(self)

    class ParallelPortfolioContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.ActorContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.ActorContext, i)

        def exp(self):
            return self.getTypedRuleContext(CoVeriLangParser.ExpContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParallelPortfolio"):
                return visitor.visitParallelPortfolio(self)
            else:
                return visitor.visitChildren(self)

    class AtomicContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.name = None  # Token
            self.version = None  # Token
            self.copyFrom(ctx)

        def actor_type(self):
            return self.getTypedRuleContext(CoVeriLangParser.Actor_typeContext, 0)

        def ID(self, i: int = None):
            if i is None:
                return self.getTokens(CoVeriLangParser.ID)
            else:
                return self.getToken(CoVeriLangParser.ID, i)

        def STRING(self, i: int = None):
            if i is None:
                return self.getTokens(CoVeriLangParser.STRING)
            else:
                return self.getToken(CoVeriLangParser.STRING, i)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAtomic"):
                return visitor.visitAtomic(self)
            else:
                return visitor.visitChildren(self)

    class IterativeContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def exp(self):
            return self.getTypedRuleContext(CoVeriLangParser.ExpContext, 0)

        def actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.ActorContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitIterative"):
                return visitor.visitIterative(self)
            else:
                return visitor.visitChildren(self)

    class SequenceContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.ActorContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.ActorContext, i)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSequence"):
                return visitor.visitSequence(self)
            else:
                return visitor.visitChildren(self)

    class ITEContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def exp(self):
            return self.getTypedRuleContext(CoVeriLangParser.ExpContext, 0)

        def actor(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.ActorContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.ActorContext, i)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitITE"):
                return visitor.visitITE(self)
            else:
                return visitor.visitChildren(self)

    class ParallelContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.ActorContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.ActorContext, i)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParallel"):
                return visitor.visitParallel(self)
            else:
                return visitor.visitChildren(self)

    class ActorAliasContext(ActorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ActorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActorAlias"):
                return visitor.visitActorAlias(self)
            else:
                return visitor.visitChildren(self)

    def actor(self):
        localctx = CoVeriLangParser.ActorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_actor)
        self._la = 0  # Token type
        try:
            self.state = 229
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 17, self._ctx)
            if la_ == 1:
                localctx = CoVeriLangParser.AtomicContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 152
                self.match(CoVeriLangParser.T__12)
                self.state = 153
                self.actor_type()
                self.state = 154
                self.match(CoVeriLangParser.T__5)
                self.state = 155
                localctx.name = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == 39 or _la == 40):
                    localctx.name = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 158
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == 6:
                    self.state = 156
                    self.match(CoVeriLangParser.T__5)
                    self.state = 157
                    localctx.version = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not (_la == 39 or _la == 40):
                        localctx.version = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

                self.state = 160
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 2:
                localctx = CoVeriLangParser.FunCallContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 162
                self.match(CoVeriLangParser.ID)
                self.state = 163
                self.match(CoVeriLangParser.T__1)
                self.state = 165
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == 39:
                    self.state = 164
                    self.id_list()

                self.state = 167
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 3:
                localctx = CoVeriLangParser.UtilityContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 168
                self.utility_actor()
                pass

            elif la_ == 4:
                localctx = CoVeriLangParser.SequenceContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 169
                self.match(CoVeriLangParser.T__13)
                self.state = 170
                self.match(CoVeriLangParser.T__1)
                self.state = 171
                self.actor()
                self.state = 174
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 172
                    self.match(CoVeriLangParser.T__5)
                    self.state = 173
                    self.actor()
                    self.state = 176
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == 6):
                        break

                self.state = 178
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 5:
                localctx = CoVeriLangParser.ITEContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 180
                self.match(CoVeriLangParser.T__14)
                self.state = 181
                self.match(CoVeriLangParser.T__1)
                self.state = 182
                self.exp(0)
                self.state = 183
                self.match(CoVeriLangParser.T__5)
                self.state = 184
                self.actor()
                self.state = 187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == 6:
                    self.state = 185
                    self.match(CoVeriLangParser.T__5)
                    self.state = 186
                    self.actor()

                self.state = 189
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 6:
                localctx = CoVeriLangParser.IterativeContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 191
                self.match(CoVeriLangParser.T__15)
                self.state = 192
                self.match(CoVeriLangParser.T__1)
                self.state = 193
                self.exp(0)
                self.state = 194
                self.match(CoVeriLangParser.T__5)
                self.state = 195
                self.actor()
                self.state = 196
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 7:
                localctx = CoVeriLangParser.ParallelContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 198
                self.match(CoVeriLangParser.T__16)
                self.state = 199
                self.match(CoVeriLangParser.T__1)
                self.state = 200
                self.actor()
                self.state = 203
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 201
                    self.match(CoVeriLangParser.T__5)
                    self.state = 202
                    self.actor()
                    self.state = 205
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == 6):
                        break

                self.state = 207
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 8:
                localctx = CoVeriLangParser.ParallelPortfolioContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 209
                self.match(CoVeriLangParser.T__17)
                self.state = 210
                self.match(CoVeriLangParser.T__1)
                self.state = 211
                self.actor()
                self.state = 216
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 16, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 212
                        self.match(CoVeriLangParser.T__5)
                        self.state = 213
                        self.actor()
                    self.state = 218
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 16, self._ctx)

                self.state = 219
                self.match(CoVeriLangParser.T__5)
                self.state = 220
                self.exp(0)
                self.state = 222
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 9:
                localctx = CoVeriLangParser.ActorAliasContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 224
                self.match(CoVeriLangParser.ID)
                pass

            elif la_ == 10:
                localctx = CoVeriLangParser.ParenthesisContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 225
                self.match(CoVeriLangParser.T__1)
                self.state = 226
                self.actor()
                self.state = 227
                self.match(CoVeriLangParser.T__2)
                pass

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

    class Utility_actorContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_utility_actor

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class JoinerContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def artifact_type(self):
            return self.getTypedRuleContext(CoVeriLangParser.Artifact_typeContext, 0)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

        def quoted_ID(self):
            return self.getTypedRuleContext(CoVeriLangParser.Quoted_IDContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitJoiner"):
                return visitor.visitJoiner(self)
            else:
                return visitor.visitChildren(self)

    class TestSpecToSpecContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTestSpecToSpec"):
                return visitor.visitTestSpecToSpec(self)
            else:
                return visitor.visitChildren(self)

    class SpecToTestSpecContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSpecToTestSpec"):
                return visitor.visitSpecToTestSpec(self)
            else:
                return visitor.visitChildren(self)

    class CopyContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCopy"):
                return visitor.visitCopy(self)
            else:
                return visitor.visitChildren(self)

    class SetterContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def quoted_ID(self):
            return self.getTypedRuleContext(CoVeriLangParser.Quoted_IDContext, 0)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSetter"):
                return visitor.visitSetter(self)
            else:
                return visitor.visitChildren(self)

    class IdentityContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def actor(self):
            return self.getTypedRuleContext(CoVeriLangParser.ActorContext, 0)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitIdentity"):
                return visitor.visitIdentity(self)
            else:
                return visitor.visitChildren(self)

    class RenameContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRename"):
                return visitor.visitRename(self)
            else:
                return visitor.visitChildren(self)

    class ClassificationToActorDefinitionContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassificationToActorDefinition"):
                return visitor.visitClassificationToActorDefinition(self)
            else:
                return visitor.visitChildren(self)

    class ComparatorContext(Utility_actorContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.Utility_actorContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def artifact_type(self):
            return self.getTypedRuleContext(CoVeriLangParser.Artifact_typeContext, 0)

        def arg_map(self):
            return self.getTypedRuleContext(CoVeriLangParser.Arg_mapContext, 0)

        def quoted_ID(self):
            return self.getTypedRuleContext(CoVeriLangParser.Quoted_IDContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitComparator"):
                return visitor.visitComparator(self)
            else:
                return visitor.visitChildren(self)

    def utility_actor(self):
        localctx = CoVeriLangParser.Utility_actorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_utility_actor)
        try:
            self.state = 277
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [19]:
                localctx = CoVeriLangParser.JoinerContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 231
                self.match(CoVeriLangParser.T__18)
                self.state = 232
                self.match(CoVeriLangParser.T__1)
                self.state = 233
                self.artifact_type()
                self.state = 234
                self.match(CoVeriLangParser.T__5)
                self.state = 235
                self.arg_map()
                self.state = 236
                self.match(CoVeriLangParser.T__5)
                self.state = 237
                self.quoted_ID()
                self.state = 238
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [20]:
                localctx = CoVeriLangParser.SetterContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 240
                self.match(CoVeriLangParser.T__19)
                self.state = 241
                self.match(CoVeriLangParser.T__1)
                self.state = 242
                self.quoted_ID()
                self.state = 243
                self.match(CoVeriLangParser.T__5)
                self.state = 244
                self.match(CoVeriLangParser.ID)
                self.state = 245
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [21]:
                localctx = CoVeriLangParser.ComparatorContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 247
                self.match(CoVeriLangParser.T__20)
                self.state = 248
                self.match(CoVeriLangParser.T__1)
                self.state = 249
                self.artifact_type()
                self.state = 250
                self.match(CoVeriLangParser.T__5)
                self.state = 251
                self.arg_map()
                self.state = 252
                self.match(CoVeriLangParser.T__5)
                self.state = 253
                self.quoted_ID()
                self.state = 254
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [22]:
                localctx = CoVeriLangParser.CopyContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 256
                self.match(CoVeriLangParser.T__21)
                self.state = 257
                self.match(CoVeriLangParser.T__1)
                self.state = 258
                self.arg_map()
                self.state = 259
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [23]:
                localctx = CoVeriLangParser.RenameContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 261
                self.match(CoVeriLangParser.T__22)
                self.state = 262
                self.match(CoVeriLangParser.T__1)
                self.state = 263
                self.arg_map()
                self.state = 264
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [24]:
                localctx = CoVeriLangParser.TestSpecToSpecContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 266
                self.match(CoVeriLangParser.T__23)
                pass
            elif token in [25]:
                localctx = CoVeriLangParser.SpecToTestSpecContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 267
                self.match(CoVeriLangParser.T__24)
                pass
            elif token in [26]:
                localctx = CoVeriLangParser.ClassificationToActorDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 8)
                self.state = 268
                self.match(CoVeriLangParser.T__25)
                pass
            elif token in [27]:
                localctx = CoVeriLangParser.IdentityContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 269
                self.match(CoVeriLangParser.T__26)
                self.state = 270
                self.match(CoVeriLangParser.T__1)
                self.state = 273
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [
                    2,
                    13,
                    14,
                    15,
                    16,
                    17,
                    18,
                    19,
                    20,
                    21,
                    22,
                    23,
                    24,
                    25,
                    26,
                    27,
                    39,
                ]:
                    self.state = 271
                    self.actor()
                    pass
                elif token in [4]:
                    self.state = 272
                    self.arg_map()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 275
                self.match(CoVeriLangParser.T__2)
                pass
            else:
                raise NoViableAltException(self)

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

    class ArtifactContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_artifact

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class ArtifactFromMapItemContext(ArtifactContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ArtifactContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self, i: int = None):
            if i is None:
                return self.getTokens(CoVeriLangParser.ID)
            else:
                return self.getToken(CoVeriLangParser.ID, i)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArtifactFromMapItem"):
                return visitor.visitArtifactFromMapItem(self)
            else:
                return visitor.visitChildren(self)

    class ArtifactAliasContext(ArtifactContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ArtifactContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArtifactAlias"):
                return visitor.visitArtifactAlias(self)
            else:
                return visitor.visitChildren(self)

    class CreateArtifactContext(ArtifactContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ArtifactContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def artifact_type(self):
            return self.getTypedRuleContext(CoVeriLangParser.Artifact_typeContext, 0)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def STRING(self):
            return self.getToken(CoVeriLangParser.STRING, 0)

        def data_model(self):
            return self.getTypedRuleContext(CoVeriLangParser.Data_modelContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCreateArtifact"):
                return visitor.visitCreateArtifact(self)
            else:
                return visitor.visitChildren(self)

    def artifact(self):
        localctx = CoVeriLangParser.ArtifactContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_artifact)
        self._la = 0  # Token type
        try:
            self.state = 293
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 21, self._ctx)
            if la_ == 1:
                localctx = CoVeriLangParser.CreateArtifactContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 279
                self.match(CoVeriLangParser.T__27)
                self.state = 280
                self.artifact_type()
                self.state = 281
                self.match(CoVeriLangParser.T__5)
                self.state = 282
                _la = self._input.LA(1)
                if not (_la == 39 or _la == 40):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 285
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == 6:
                    self.state = 283
                    self.match(CoVeriLangParser.T__5)
                    self.state = 284
                    self.data_model()

                self.state = 287
                self.match(CoVeriLangParser.T__2)
                pass

            elif la_ == 2:
                localctx = CoVeriLangParser.ArtifactAliasContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 289
                self.match(CoVeriLangParser.ID)
                pass

            elif la_ == 3:
                localctx = CoVeriLangParser.ArtifactFromMapItemContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 290
                self.match(CoVeriLangParser.ID)
                self.state = 291
                self.match(CoVeriLangParser.T__28)
                self.state = 292
                self.match(CoVeriLangParser.ID)
                pass

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

    class Artifact_typeContext(ParserRuleContext):
        __slots__ = "parser"

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

        def TYPE_NAME(self):
            return self.getToken(CoVeriLangParser.TYPE_NAME, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_artifact_type

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArtifact_type"):
                return visitor.visitArtifact_type(self)
            else:
                return visitor.visitChildren(self)

    def artifact_type(self):
        localctx = CoVeriLangParser.Artifact_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_artifact_type)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 295
            self.match(CoVeriLangParser.TYPE_NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Data_modelContext(ParserRuleContext):
        __slots__ = "parser"

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

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_data_model

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitData_model"):
                return visitor.visitData_model(self)
            else:
                return visitor.visitChildren(self)

    def data_model(self):
        localctx = CoVeriLangParser.Data_modelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_data_model)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 297
            _la = self._input.LA(1)
            if not (((_la) & ~0x3F) == 0 and ((1 << _la) & 552977039360) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Actor_typeContext(ParserRuleContext):
        __slots__ = "parser"

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

        def TYPE_NAME(self):
            return self.getToken(CoVeriLangParser.TYPE_NAME, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_actor_type

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActor_type"):
                return visitor.visitActor_type(self)
            else:
                return visitor.visitChildren(self)

    def actor_type(self):
        localctx = CoVeriLangParser.Actor_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_actor_type)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 299
            self.match(CoVeriLangParser.TYPE_NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_exp

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class ExpAliasContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExpAlias"):
                return visitor.visitExpAlias(self)
            else:
                return visitor.visitChildren(self)

    class NotLogicalContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def exp(self):
            return self.getTypedRuleContext(CoVeriLangParser.ExpContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitNotLogical"):
                return visitor.visitNotLogical(self)
            else:
                return visitor.visitChildren(self)

    class InstanceOfContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def artifact_type(self):
            return self.getTypedRuleContext(CoVeriLangParser.Artifact_typeContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInstanceOf"):
                return visitor.visitInstanceOf(self)
            else:
                return visitor.visitChildren(self)

    class ElementOfContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def verdict_list(self):
            return self.getTypedRuleContext(CoVeriLangParser.Verdict_listContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElementOf"):
                return visitor.visitElementOf(self)
            else:
                return visitor.visitChildren(self)

    class QuotedExpAliasForArtifactsContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def quoted_ID(self):
            return self.getTypedRuleContext(CoVeriLangParser.Quoted_IDContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitQuotedExpAliasForArtifacts"):
                return visitor.visitQuotedExpAliasForArtifacts(self)
            else:
                return visitor.visitChildren(self)

    class BinaryLogicalContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def exp(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(CoVeriLangParser.ExpContext)
            else:
                return self.getTypedRuleContext(CoVeriLangParser.ExpContext, i)

        def BIN_OP(self):
            return self.getToken(CoVeriLangParser.BIN_OP, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBinaryLogical"):
                return visitor.visitBinaryLogical(self)
            else:
                return visitor.visitChildren(self)

    class ParenContext(ExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a CoVeriLangParser.ExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def exp(self):
            return self.getTypedRuleContext(CoVeriLangParser.ExpContext, 0)

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParen"):
                return visitor.visitParen(self)
            else:
                return visitor.visitChildren(self)

    def exp(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CoVeriLangParser.ExpContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 40
        self.enterRecursionRule(localctx, 40, self.RULE_exp, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 326
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [32]:
                localctx = CoVeriLangParser.NotLogicalContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 302
                self.match(CoVeriLangParser.T__31)
                self.state = 303
                self.exp(6)
                pass
            elif token in [33]:
                localctx = CoVeriLangParser.InstanceOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 304
                self.match(CoVeriLangParser.T__32)
                self.state = 305
                self.match(CoVeriLangParser.T__1)
                self.state = 306
                self.match(CoVeriLangParser.ID)
                self.state = 307
                self.match(CoVeriLangParser.T__5)
                self.state = 308
                self.artifact_type()
                self.state = 309
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [34]:
                localctx = CoVeriLangParser.ElementOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 311
                self.match(CoVeriLangParser.T__33)
                self.state = 312
                self.match(CoVeriLangParser.T__1)
                self.state = 313
                self.match(CoVeriLangParser.ID)
                self.state = 314
                self.match(CoVeriLangParser.T__5)
                self.state = 315
                self.match(CoVeriLangParser.T__3)
                self.state = 316
                self.verdict_list()
                self.state = 317
                self.match(CoVeriLangParser.T__4)
                self.state = 318
                self.match(CoVeriLangParser.T__2)
                pass
            elif token in [39]:
                localctx = CoVeriLangParser.ExpAliasContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 320
                self.match(CoVeriLangParser.ID)
                pass
            elif token in [36]:
                localctx = CoVeriLangParser.QuotedExpAliasForArtifactsContext(
                    self, localctx
                )
                self._ctx = localctx
                _prevctx = localctx
                self.state = 321
                self.quoted_ID()
                pass
            elif token in [2]:
                localctx = CoVeriLangParser.ParenContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 322
                self.match(CoVeriLangParser.T__1)
                self.state = 323
                self.exp(0)
                self.state = 324
                self.match(CoVeriLangParser.T__2)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 333
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 23, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CoVeriLangParser.BinaryLogicalContext(
                        self,
                        CoVeriLangParser.ExpContext(self, _parentctx, _parentState),
                    )
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                    self.state = 328
                    if not self.precpred(self._ctx, 7):
                        from antlr4.error.Errors import FailedPredicateException

                        raise FailedPredicateException(
                            self, "self.precpred(self._ctx, 7)"
                        )
                    self.state = 329
                    self.match(CoVeriLangParser.BIN_OP)
                    self.state = 330
                    self.exp(8)
                self.state = 335
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 23, self._ctx)

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

    class Verdict_listContext(ParserRuleContext):
        __slots__ = "parser"

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

        def VERDICT(self, i: int = None):
            if i is None:
                return self.getTokens(CoVeriLangParser.VERDICT)
            else:
                return self.getToken(CoVeriLangParser.VERDICT, i)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_verdict_list

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVerdict_list"):
                return visitor.visitVerdict_list(self)
            else:
                return visitor.visitChildren(self)

    def verdict_list(self):
        localctx = CoVeriLangParser.Verdict_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_verdict_list)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self.match(CoVeriLangParser.VERDICT)
            self.state = 341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == 6:
                self.state = 337
                self.match(CoVeriLangParser.T__5)
                self.state = 338
                self.match(CoVeriLangParser.VERDICT)
                self.state = 343
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class Tc_expContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_tc_exp

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTc_exp"):
                return visitor.visitTc_exp(self)
            else:
                return visitor.visitChildren(self)

    def tc_exp(self):
        localctx = CoVeriLangParser.Tc_expContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_tc_exp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 344
            self.match(CoVeriLangParser.T__34)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Quoted_ID_with_maybe_typeContext(ParserRuleContext):
        __slots__ = "parser"

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

        def quoted_ID(self):
            return self.getTypedRuleContext(CoVeriLangParser.Quoted_IDContext, 0)

        def TYPE_NAME(self):
            return self.getToken(CoVeriLangParser.TYPE_NAME, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_quoted_ID_with_maybe_type

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitQuoted_ID_with_maybe_type"):
                return visitor.visitQuoted_ID_with_maybe_type(self)
            else:
                return visitor.visitChildren(self)

    def quoted_ID_with_maybe_type(self):
        localctx = CoVeriLangParser.Quoted_ID_with_maybe_typeContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 46, self.RULE_quoted_ID_with_maybe_type)
        try:
            self.state = 353
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [36]:
                self.enterOuterAlt(localctx, 1)
                self.state = 346
                self.quoted_ID()
                pass
            elif token in [2]:
                self.enterOuterAlt(localctx, 2)
                self.state = 347
                self.match(CoVeriLangParser.T__1)
                self.state = 348
                self.quoted_ID()
                self.state = 349
                self.match(CoVeriLangParser.T__5)
                self.state = 350
                self.match(CoVeriLangParser.TYPE_NAME)
                self.state = 351
                self.match(CoVeriLangParser.T__2)
                pass
            else:
                raise NoViableAltException(self)

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

    class Quoted_IDContext(ParserRuleContext):
        __slots__ = "parser"

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

        def ID(self):
            return self.getToken(CoVeriLangParser.ID, 0)

        def getRuleIndex(self):
            return CoVeriLangParser.RULE_quoted_ID

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

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

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitQuoted_ID"):
                return visitor.visitQuoted_ID(self)
            else:
                return visitor.visitChildren(self)

    def quoted_ID(self):
        localctx = CoVeriLangParser.Quoted_IDContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_quoted_ID)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 355
            self.match(CoVeriLangParser.T__35)
            self.state = 356
            self.match(CoVeriLangParser.ID)
            self.state = 357
            self.match(CoVeriLangParser.T__35)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[20] = self.exp_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def exp_sempred(self, localctx: ExpContext, predIndex: int):
        if predIndex == 0:
            return self.precpred(self._ctx, 7)
