Exemple #1
0
def create_array_message() -> Message:
    length_type = ModularInteger("Arrays.Length", Pow(Number(2), Number(8)))

    modular_type = ModularInteger("Arrays.Modular_Integer",
                                  Pow(Number(2), Number(16)))
    modular_vector_type = Array("Arrays.Modular_Vector", modular_type)

    range_type = RangeInteger("Arrays.Range_Integer", Number(1), Number(100),
                              Number(8))
    range_vector_type = Array("Arrays.Range_Vector", range_type)

    enum_type = Enumeration(
        "Arrays.Enumeration",
        {
            "ZERO": Number(0),
            "ONE": Number(1),
            "TWO": Number(2)
        },
        Number(8),
        False,
    )
    enum_vector_type = Array("Arrays.Enumeration_Vector", enum_type)

    av_enum_type = Enumeration(
        "Arrays.AV_Enumeration",
        {
            "AV_ZERO": Number(0),
            "AV_ONE": Number(1),
            "AV_TWO": Number(2)
        },
        Number(8),
        True,
    )
    av_enum_vector_type = Array("Arrays.AV_Enumeration_Vector", av_enum_type)

    structure = [
        Link(INITIAL, Field("Length")),
        Link(Field("Length"),
             Field("Modular_Vector"),
             length=Mul(Variable("Length"), Number(8))),
        Link(Field("Modular_Vector"), Field("Range_Vector"),
             length=Number(16)),
        Link(Field("Range_Vector"),
             Field("Enumeration_Vector"),
             length=Number(16)),
        Link(Field("Enumeration_Vector"),
             Field("AV_Enumeration_Vector"),
             length=Number(16)),
        Link(Field("AV_Enumeration_Vector"), FINAL),
    ]

    types = {
        Field("Length"): length_type,
        Field("Modular_Vector"): modular_vector_type,
        Field("Range_Vector"): range_vector_type,
        Field("Enumeration_Vector"): enum_vector_type,
        Field("AV_Enumeration_Vector"): av_enum_vector_type,
    }

    return Message("Arrays.Message", structure, types)
Exemple #2
0
def test_enumeration_invalid_literal() -> None:
    assert_type_error(
        Enumeration("P.T", [("A B", Number(1))], Number(8), False,
                    Location(((1, 2)))),
        r'^<stdin>:1:2: model: error: invalid literal name "A B" in "T"$',
    )
    assert_type_error(
        Enumeration("P.T", [("A.B", Number(1))], Number(8), False,
                    Location((6, 4))),
        r'^<stdin>:6:4: model: error: invalid literal name "A.B" in "T"$',
    )
Exemple #3
0
def test_enumeration_invalid_literal_value() -> None:
    assert_type_error(
        Enumeration("P.T", [("A", Number(2**63))], Number(64), False,
                    Location((10, 5))),
        r'^<stdin>:10:5: model: error: enumeration value of "T"'
        r" outside of permitted range \(0 .. 2\*\*63 - 1\)$",
    )
Exemple #4
0
def parse_type(string: str, location: int, tokens: ParseResults) -> Type:
    try:
        name = tokens[1]
        full_name = f"__PACKAGE__.{name}"
        if tokens[3] == "mod":
            return ModularInteger(full_name, *tokens[4:6])
        if tokens[3] == "range":
            tokens[6] = tokens[6]["size"]
            return RangeInteger(full_name, *tokens[4:7])
        if tokens[3] == "message":
            return MessageSpec(full_name, tokens[4])
        if tokens[3] == "null message":
            return MessageSpec(full_name, [])
        if tokens[3] == "(":
            elements = dict(tokens[4:-2])
            aspects = tokens[-1]
            if len(elements) < len(tokens[4:-2]):
                raise ModelError(f'"{name}" contains duplicate elements')
            if "always_valid" not in aspects:
                aspects["always_valid"] = False
            return Enumeration(full_name, elements, aspects["size"],
                               aspects["always_valid"])
        if tokens[3] == "new":
            return DerivationSpec(full_name, tokens[4])
        if tokens[3] == "array of":
            return Array(
                full_name,
                Reference(tokens[4] if "." in
                          tokens[4] else f"__PACKAGE__.{tokens[4]}"))
    except ModelError as e:
        raise ParseFatalException(string, location, e)
    raise ParseFatalException(string, location, "unexpected type")
Exemple #5
0
def create_tlv_message() -> Message:
    tag_type = Enumeration("TLV.Tag", {
        "Msg_Data": Number(1),
        "Msg_Error": Number(3)
    }, Number(2), False)
    length_type = ModularInteger("TLV.Length", Pow(Number(2), Number(14)))

    structure = [
        Link(INITIAL, Field("Tag")),
        Link(Field("Tag"), Field("Length"),
             Equal(Variable("Tag"), Variable("Msg_Data"))),
        Link(Field("Tag"), FINAL, Equal(Variable("Tag"),
                                        Variable("Msg_Error"))),
        Link(Field("Length"),
             Field("Value"),
             length=Mul(Variable("Length"), Number(8))),
        Link(Field("Value"), FINAL),
    ]

    types = {
        Field("Tag"): tag_type,
        Field("Length"): length_type,
        Field("Value"): Payload()
    }

    return Message("TLV.Message", structure, types)
Exemple #6
0
def parse_type(string: str, location: int, tokens: list) -> Type:
    try:
        if tokens[3] == 'mod':
            return ModularInteger(tokens[1], *tokens[4:6])
        if tokens[3] == 'range':
            tokens[6] = tokens[6]['size']
            return RangeInteger(tokens[1], *tokens[4:7])
        if tokens[3] == 'message':
            return Message(tokens[1], tokens[4])
        if tokens[3] == '(':
            elements = dict(tokens[4:-2])
            aspects = tokens[-1]
            if len(elements) < len(tokens[4:-2]):
                raise ModelError(f'"{tokens[1]}" contains duplicate elements')
            if 'always_valid' not in aspects:
                aspects['always_valid'] = False
            return Enumeration(tokens[1], elements, aspects['size'],
                               aspects['always_valid'])
        if tokens[3] == 'new':
            if len(tokens) == 7:
                tokens.append(TRUE)
            return Refinement(tokens[1], *tokens[4:])
        if tokens[3] == 'array of':
            return Array(tokens[1], tokens[4])
    except ModelError as e:
        raise ParseFatalException(string, location, e)
    raise ParseFatalException(string, location, 'unexpected type')
Exemple #7
0
def enumerations(
    draw: Draw,
    unique_identifiers: ty.Generator[ID, None, None],
    multiple_of_8: bool = False,
    align_to_8: int = 0,
) -> Enumeration:
    @st.composite
    def literal_identifiers(_: ty.Callable[[], object]) -> str:
        assert unique_identifiers
        return str(next(unique_identifiers).name)

    size = draw(sizes(multiple_of_8, align_to_8))
    literals = draw(
        st.lists(
            st.tuples(
                literal_identifiers(),
                st.builds(
                    expr.Number, st.integers(min_value=0, max_value=min(2**size - 1, 2**63 - 1))
                ),
            ),
            unique_by=(lambda x: x[0], lambda x: x[1]),  # type: ignore[no-any-return]
            min_size=1,
            max_size=2**size,
        )
    )

    return Enumeration(
        next(unique_identifiers),
        literals,
        expr.Number(size),
        draw(st.booleans()) if len(literals) < 2**size else False,
    )
Exemple #8
0
def test_invalid_enumeration_type_identical_literals() -> None:
    assert_model_error(
        [
            Enumeration(
                "P::T1",
                [("Foo", Number(1)), (ID("Bar", Location((3, 33))), Number(2))],
                Number(1),
                always_valid=False,
            ),
            Enumeration(
                "P::T2",
                [("Bar", Number(1)), ("Baz", Number(2))],
                Number(1),
                always_valid=False,
                location=Location((4, 16)),
            ),
        ],
        r"<stdin>:4:16: model: error: conflicting literals: Bar\n"
        r'<stdin>:3:33: model: info: previous occurrence of "Bar"',
    )
Exemple #9
0
def test_invalid_enumeration_type_duplicate_elements() -> None:
    assert_type_error(
        Enumeration(
            "P.T",
            [(ID("Foo", Location((3, 27))), Number(1)),
             (ID("Foo", Location((3, 32))), Number(2))],
            Number(1),
            False,
        ),
        r'<stdin>:3:32: model: error: duplicate literal "Foo"\n'
        r"<stdin>:3:27: model: info: previous occurrence",
    )
Exemple #10
0
def create_enumeration_pdu() -> PDU:
    priority_type = Enumeration('Priority',
                                {'LOW': Number(1), 'MEDIUM': Number(4), 'HIGH': Number(7)},
                                Number(3),
                                True)

    initial = InitialNode()
    priority = Node('Priority', priority_type)

    initial.edges = [Edge(priority)]
    priority.edges = [Edge(FINAL)]

    return PDU('Enumeration.Message', initial)
Exemple #11
0
def test_invalid_type_condition_enum() -> None:
    structure = [
        Link(INITIAL, Field("F1")),
        Link(
            Field("F1"),
            Field("F2"),
            condition=Equal(Variable("F1"),
                            Variable("E4"),
                            location=Location((22, 10))),
        ),
        Link(Field("F2"), FINAL),
    ]
    e1 = Enumeration(
        "P.E1",
        [("E1", Number(1)), ("E2", Number(2)), ("E3", Number(3))],
        Number(8),
        False,
        Location((10, 4)),
    )
    e2 = Enumeration(
        "P.E2",
        [("E4", Number(1)), ("E5", Number(2)), ("E6", Number(3))],
        Number(8),
        False,
        Location((11, 4)),
    )
    types = {
        Field("F1"): e1,
        Field("F2"): e2,
    }
    assert_message_model_error(
        structure,
        types,
        r"^"
        r"<stdin>:22:10: model: error: comparison of incompatible enumeration literals\n"
        r'<stdin>:10:4: model: info: of type "P.E1"\n'
        r'<stdin>:11:4: model: info: and type "P.E2"'
        r"$",
    )
Exemple #12
0
def test_enumeration_type_spec() -> None:
    spec = {
        "Enumeration_Type": Specification(
            ContextSpec([]),
            PackageSpec(
                "Enumeration_Type",
                [
                    Enumeration(
                        "__PACKAGE__.Day",
                        [
                            ("Mon", Number(1)),
                            ("Tue", Number(2)),
                            ("Wed", Number(3)),
                            ("Thu", Number(4)),
                            ("Fri", Number(5)),
                            ("Sat", Number(6)),
                            ("Sun", Number(7)),
                        ],
                        Number(3),
                        False,
                    ),
                    Enumeration(
                        "__PACKAGE__.Gender",
                        [("M", Number(0)), ("F", Number(1))],
                        Number(1),
                        False,
                    ),
                    Enumeration(
                        "__PACKAGE__.Priority",
                        [("LOW", Number(1)), ("MEDIUM", Number(4)), ("HIGH", Number(7))],
                        Number(8),
                        True,
                    ),
                ],
            ),
        )
    }
    assert_specifications_files([f"{TESTDIR}/enumeration_type.rflx"], spec)
Exemple #13
0
    def test_nonexistent_variable(self) -> None:
        mod_type = ModularInteger("P.MT", Pow(Number(2), Number(32)))
        enum_type = Enumeration("P.ET", {"Val1": Number(0), "Val2": Number(1)}, Number(8), True)
        structure = [
            Link(INITIAL, Field("F1")),
            Link(Field("F1"), Field("F2"), Equal(Variable("F1"), Variable("Val3"))),
            Link(Field("F2"), FINAL),
        ]

        types = {Field("F1"): enum_type, Field("F2"): mod_type}
        with self.assertRaisesRegex(
            ModelError,
            '^undefined variable "Val3" referenced in ' + 'condition 0 from field "F1" to "F2"',
        ):
            Message("P.M", structure, types)
Exemple #14
0
def test_invalid_enumeration_type_builtin_literals() -> None:
    assert_model_error(
        [
            Enumeration(
                "P.T",
                [("True", Number(1)), ("False", Number(2))],
                Number(1),
                False,
                Location((3, 16)),
            ),
        ],
        r"<stdin>:3:16: model: error: conflicting literals: False, True\n"
        r'__BUILTINS__:0:0: model: info: previous occurrence of "False"\n'
        r'__BUILTINS__:0:0: model: info: previous occurrence of "True"',
    )
Exemple #15
0
def test_conflicting_literal_builtin_type() -> None:
    assert_model_error(
        [
            Enumeration(
                "P.T",
                [
                    (ID("E1", Location((3, 27))), Number(1)),
                    (ID("Boolean", Location((3, 31))), Number(2)),
                ],
                Number(8),
                False,
            ),
        ],
        r'<stdin>:3:31: model: error: literal conflicts with type "Boolean"\n'
        r"__BUILTINS__:0:0: model: info: conflicting type declaration",
    )
Exemple #16
0
def create_enumeration_message() -> Message:
    priority_type = Enumeration(
        "Enumeration.Priority",
        {
            "LOW": Number(1),
            "MEDIUM": Number(4),
            "HIGH": Number(7)
        },
        Number(3),
        True,
    )

    structure = [
        Link(INITIAL, Field("Priority")),
        Link(Field("Priority"), FINAL)
    ]

    types = {Field("Priority"): priority_type}

    return Message("Enumeration.Message", structure, types)
Exemple #17
0
def test_name_conflict_between_literal_and_type() -> None:
    assert_model_error(
        [
            Enumeration(
                "P::T",
                [
                    (ID("FOO", Location((3, 27))), Number(1)),
                    (ID("BAR", Location((3, 32))), Number(2)),
                ],
                Number(1),
                always_valid=False,
            ),
            ModularInteger("P::Foo", Number(256), Location((4, 16))),
            ModularInteger("P::Bar", Number(256), Location((5, 16))),
        ],
        r'<stdin>:3:27: model: error: literal "FOO" conflicts with type declaration\n'
        r'<stdin>:4:16: model: info: conflicting type "P::Foo"\n'
        r'<stdin>:3:32: model: error: literal "BAR" conflicts with type declaration\n'
        r'<stdin>:5:16: model: info: conflicting type "P::Bar"',
    )
Exemple #18
0
def test_name_conflict_between_literal_and_type() -> None:
    assert_model_error(
        [
            Enumeration(
                "P.T",
                [
                    (ID("Foo", Location((3, 27))), Number(1)),
                    (ID("Bar", Location((3, 32))), Number(2)),
                ],
                Number(1),
                False,
            ),
            ModularInteger("T.Foo", Number(256), Location((4, 16))),
            ModularInteger("T.Bar", Number(256), Location((5, 16))),
        ],
        r'<stdin>:3:32: model: error: literal conflicts with type "Bar"\n'
        r"<stdin>:5:16: model: info: conflicting type declaration\n"
        r'<stdin>:3:27: model: error: literal conflicts with type "Foo"\n'
        r"<stdin>:4:16: model: info: conflicting type declaration",
    )
Exemple #19
0
def test_message_nonexistent_variable() -> None:
    mod_type = ModularInteger("P.MT", Pow(Number(2), Number(32)))
    enum_type = Enumeration("P.ET", [("Val1", Number(0)), ("Val2", Number(1))],
                            Number(8), True)
    structure = [
        Link(INITIAL, Field("F1")),
        Link(
            Field("F1"),
            Field("F2"),
            Equal(Variable("F1"), Variable("Val3",
                                           location=Location((444, 55)))),
        ),
        Link(Field("F2"), FINAL),
    ]

    types = {Field("F1"): enum_type, Field("F2"): mod_type}
    assert_message_model_error(
        structure,
        types,
        '^<stdin>:444:55: model: error: undefined variable "Val3" referenced$',
    )
Exemple #20
0
def test_message_name_conflict_field_enum() -> None:
    t = Enumeration(
        "P.T",
        [(ID("X", Location((3, 27))), Number(1)),
         (ID("Y", Location((3, 32))), Number(2))],
        Number(8),
        False,
    )

    structure = [
        Link(INITIAL, Field("X")),
        Link(Field("X"), FINAL),
    ]

    types = {Field(ID("X", Location((5, 6)))): t}

    assert_message_model_error(
        structure,
        types,
        '^<stdin>:5:6: model: error: name conflict for field "X" in "P.M"\n'
        "<stdin>:3:27: model: info: conflicting enumeration literal",
    )
Exemple #21
0
def test_exclusive_prefixed_enum_valid() -> None:
    structure = [
        Link(INITIAL, Field("F1")),
        Link(Field("F1"),
             FINAL,
             condition=Equal(Variable("F1"), Variable("ONE"))),
        Link(Field("F1"),
             Field("F2"),
             condition=Equal(Variable("F1"), Variable("P.TWO"))),
        Link(Field("F2"), FINAL),
    ]
    types = {
        Field("F1"):
        ENUMERATION,
        Field("F2"):
        Enumeration(
            "P2.Enumeration",
            [("ONE", Number(2)), ("TWO", Number(1))],
            Number(8),
            False,
        ),
    }
    Message("P.M", structure, types)
Exemple #22
0
def parse_type(string: str, location: int, tokens: ParseResults) -> Type:
    package = ID("__PACKAGE__")
    name = tokens[1]

    locn = parser_location(tokens[0], tokens[-1], string)

    identifier = package * name

    if tokens[3] == "mod":
        return ModularInteger(identifier, tokens[4], locn)
    if tokens[3] == "range":
        tokens[6] = tokens[6]["size"]
        return RangeInteger(identifier, tokens[4], tokens[5], tokens[6], locn)
    if tokens[3] == "message":
        return MessageSpec(identifier, tokens[4], locn)
    if tokens[3] == "null message":
        return MessageSpec(identifier, [], locn)
    if tokens[3] == "(":
        elements = tokens[4:-3]
        aspects = tokens[-2]
        if "always_valid" not in aspects:
            aspects["always_valid"] = False
        enumeration = Enumeration(identifier, elements, aspects["size"],
                                  aspects["always_valid"], locn)
        return enumeration
    if tokens[3] == "new":
        return DerivationSpec(identifier, tokens[4], locn)
    if tokens[3] == "array of":
        return ArraySpec(
            identifier,
            ReferenceSpec(qualified_type_name(tokens[4], package),
                          tokens[4].location),
            locn,
        )

    raise ParseFatalException(string, location, "unexpected type")
Exemple #23
0
def fixture_enum_value_imported() -> EnumValue:
    return EnumValue(
        Enumeration("Test.Enum", [("One", Number(1)), ("Two", Number(2))], Number(8), False),
        imported=True,
    )
Exemple #24
0
    DerivedMessage,
    Enumeration,
    Field,
    Link,
    Message,
    Model,
    ModularInteger,
    Opaque,
    RangeInteger,
    Refinement,
)

NULL_MESSAGE = Message("Null.Message", [], {})
NULL_MODEL = Model([NULL_MESSAGE])

TLV_TAG = Enumeration("TLV.Tag", [("Msg_Data", Number(1)),
                                  ("Msg_Error", Number(3))], Number(2), False)
TLV_LENGTH = ModularInteger("TLV.Length", Pow(Number(2), Number(14)))
TLV_MESSAGE = Message(
    "TLV.Message",
    [
        Link(INITIAL, Field("Tag")),
        Link(Field("Tag"), Field("Length"),
             Equal(Variable("Tag"), Variable("Msg_Data"))),
        Link(Field("Tag"), FINAL, Equal(Variable("Tag"),
                                        Variable("Msg_Error"))),
        Link(Field("Length"),
             Field("Value"),
             length=Mul(Variable("Length"), Number(8))),
        Link(Field("Value"), FINAL),
    ],
    {
Exemple #25
0
def test_enumeration_invalid_always_valid_aspect() -> None:
    with pytest.raises(
            RecordFluxError,
            match=r'^model: error: unnecessary always-valid aspect on "T"$'):
        Enumeration("P.T", [("A", Number(0)), ("B", Number(1))], Number(1),
                    True).error.propagate()
Exemple #26
0
def test_enumeration_invalid_size_variable() -> None:
    assert_type_error(
        Enumeration("P.T", [("A", Number(1))], Add(Number(8), Variable("X")),
                    False, Location((34, 3))),
        r'^<stdin>:34:3: model: error: size of "T" contains variable$',
    )
Exemple #27
0
def test_consistency_specification_parsing_generation(tmp_path: Path) -> None:
    tag = Enumeration(
        "Test::Tag",
        [("Msg_Data", expr.Number(1)), ("Msg_Error", expr.Number(3))],
        expr.Number(8),
        always_valid=False,
    )
    length = ModularInteger("Test::Length",
                            expr.Pow(expr.Number(2), expr.Number(16)))
    message = Message(
        "Test::Message",
        [
            Link(INITIAL, Field("Tag")),
            Link(
                Field("Tag"),
                Field("Length"),
                expr.Equal(expr.Variable("Tag"), expr.Variable("Msg_Data")),
            ),
            Link(Field("Tag"), FINAL,
                 expr.Equal(expr.Variable("Tag"), expr.Variable("Msg_Error"))),
            Link(
                Field("Length"),
                Field("Value"),
                size=expr.Mul(expr.Variable("Length"), expr.Number(8)),
            ),
            Link(Field("Value"), FINAL),
        ],
        {
            Field("Tag"): tag,
            Field("Length"): length,
            Field("Value"): OPAQUE
        },
        skip_proof=True,
    )
    session = Session(
        "Test::Session",
        "A",
        "C",
        [
            State(
                "A",
                declarations=[],
                actions=[stmt.Read("X", expr.Variable("M"))],
                transitions=[
                    Transition("B"),
                ],
            ),
            State(
                "B",
                declarations=[
                    decl.VariableDeclaration("Z", BOOLEAN.identifier,
                                             expr.Variable("Y")),
                ],
                actions=[],
                transitions=[
                    Transition(
                        "C",
                        condition=expr.And(
                            expr.Equal(expr.Variable("Z"), expr.TRUE),
                            expr.Equal(expr.Call("G", [expr.Variable("F")]),
                                       expr.TRUE),
                        ),
                        description="rfc1149.txt+45:4-47:8",
                    ),
                    Transition("A"),
                ],
                description="rfc1149.txt+51:4-52:9",
            ),
            State("C"),
        ],
        [
            decl.VariableDeclaration("M", "Test::Message"),
            decl.VariableDeclaration("Y", BOOLEAN.identifier, expr.FALSE),
        ],
        [
            decl.ChannelDeclaration("X", readable=True, writable=True),
            decl.TypeDeclaration(Private("Test::T")),
            decl.FunctionDeclaration("F", [], "Test::T"),
            decl.FunctionDeclaration("G", [decl.Argument("P", "Test::T")],
                                     BOOLEAN.identifier),
        ],
        [BOOLEAN, OPAQUE, tag, length, message],
    )
    model = Model(types=[BOOLEAN, OPAQUE, tag, length, message],
                  sessions=[session])
    model.write_specification_files(tmp_path)
    p = parser.Parser()
    p.parse(tmp_path / "test.rflx")
    parsed_model = p.create_model()
    assert parsed_model.types == model.types
    assert parsed_model.sessions == model.sessions
    assert parsed_model == model
Exemple #28
0
def test_enumeration_invalid_size_too_small() -> None:
    assert_type_error(
        Enumeration("P.T", [("A", Number(256))], Number(8), False,
                    Location((10, 5))),
        r'^<stdin>:10:5: model: error: size of "T" too small$',
    )
Exemple #29
0
    Model,
    ModularInteger,
    RangeInteger,
    Refinement,
    Sequence,
    Session,
    State,
    Transition,
    UnprovenMessage,
)

NULL_MESSAGE = Message("Null::Message", [], {}, skip_proof=True)
NULL_MODEL = Model([NULL_MESSAGE])

TLV_TAG = Enumeration(
    "TLV::Tag", [("Msg_Data", Number(1)), ("Msg_Error", Number(3))], Number(8), always_valid=False
)
TLV_LENGTH = ModularInteger("TLV::Length", Pow(Number(2), Number(16)))
TLV_MESSAGE = Message(
    "TLV::Message",
    [
        Link(INITIAL, Field("Tag")),
        Link(Field("Tag"), Field("Length"), Equal(Variable("Tag"), Variable("Msg_Data"))),
        Link(Field("Tag"), FINAL, Equal(Variable("Tag"), Variable("Msg_Error"))),
        Link(Field("Length"), Field("Value"), size=Mul(Variable("Length"), Number(8))),
        Link(Field("Value"), FINAL),
    ],
    {Field("Tag"): TLV_TAG, Field("Length"): TLV_LENGTH, Field("Value"): OPAQUE},
    skip_proof=True,
)
TLV_MODEL = Model([TLV_TAG, TLV_LENGTH, TLV_MESSAGE])
Exemple #30
0
def test_enumeration_invalid_size_exceeds_limit() -> None:
    assert_type_error(
        Enumeration("P.T", [("A", Number(256))], Number(128), False,
                    Location((8, 20))),
        r'^<stdin>:8:20: model: error: size of "T" exceeds limit \(2\*\*64\)$',
    )