varphi-devkit 2.0.6__tar.gz → 3.0.0__tar.gz

varphi_devkit-3.0.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.3
+Name: varphi-devkit
+Version: 3.0.0
+Summary: A framework for building compilers, interpreters, and analysis tools for the Varphi language.
+Author: Varphi
+Author-email: Varphi <support@varphi-lang.com>
+Requires-Dist: antlr4-python3-runtime==4.13.2
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# The Varphi Compiler Development Kit
+
+This is the official frontend parsing and compiler development kit for the Varphi programming language.
+
+The devkit is a target-language-agnostic frontent that handles lexical analysis, syntax parsing, semantic validation, and intermediate representation (IR) generation. It is designed so that downstream developers can write backend compilers (e.g., Varphi-to-Python, Varphi-to-C, ...) without needing to worry about all the "dirty work" of compilers, like lexing and parsing.
+
+---
+
+## 📦 Installation
+
+Assuming you are using a standard Python environment or a modern manager like `uv`:
+
+```
+# For pip
+pip install varphi-devkit
+# For uv
+uv pip install varphi-devkit
+```
+
+---
+
+## Quick Start: Building a Downstream Compiler
+
+Building a Varphi compiler requires inheriting from the `VarphiCompiler` base class and implementing a single method: `_generate_compiled_program()`.
+
+```python
+from varphi_devkit import VarphiCompiler
+
+class VarphiToMyLangCompiler(VarphiCompiler):
+    
+    def _generate_compiled_program(self) -> str:
+        # By the time this method is called, the devkit has already parsed, validated, and sorted the Varphi source code. 
+        
+        # self.states: A set of all state names (strings) discovered in the code.
+        print(f"Total states: {len(self.states)}")
+        
+        # self.initial_state: The entry state (string).
+        print(f"Entry point: {self.initial_state}")
+        
+        # self._tape_count: The number of tapes in this machine (int).
+        print(f"Tape count: {self._tape_count}")
+
+        # self.ir: A dictionary mapping state names to a pre-sorted list of VarphiTransitions.
+        # The VarphiTransitions are sorted in non-decreasing order of specificity
+        for state_name, transitions in self.ir.items():
+            for t in transitions:
+                # Code generation logic goes here!
+                pass
+                
+        return "Compilation Complete!"  # You would return your compiled program here
+
+# Usage
+compiler = VarphiToMyLangCompiler()
+with open("machine.vp", "r") as f:
+    compiled_code = compiler.compile(f.read())
+```
+
+---
+
+## The Intermediate Representation (IR)
+
+The devkit translates raw `.vp` source text into a strictly typed IR. Every transition rule in the user's source code is mapped to a `VarphiTransition` object.
+
+Because downstream compilers receive this IR *after* the Devkit has validated it, it has already been totally validated, saving you development time/effort.
+
+### `VarphiTransition`
+
+```python
+@dataclass(frozen=True)
+class VarphiTransition:
+    current_state: str 
+    read_symbols: tuple[ReadWriteTupleElement, ...]  
+    next_state: str
+    write_symbols: tuple[ReadWriteTupleElement, ...] 
+    shift_directions: tuple[Direction, ...]        
+    line_number: int
+    specificity: tuple[int, int]  # (unique variables, total variables)
+```
+
+---
+
+## The Specificity Engine
+
+Varphi is a nondeterministic language with pattern matching. When multiple rules match a tape state, the machine must choose the "most specific" rule, or stochastically branch if there is a tie.
+
+The Devkit calculates a specificity score for every transition, accessible through the `specificity` of a `VarphiTransition` object. Its type is a two-element tuple, where the first element gives the number of unique variables in the transition rule and the second gives the total number of variables (including dupicates) in the transition rule. 
+
+Thus, a rule containing all literals scores lower (i.e., `(0, 0)`) than one containing variables. 
+
+Before calling your compiler's generation method, the devkit groups all transitions by state and sorts them in non-decreasing order of specificity. Downstream runtimes can simply iterate over a state's transitions, gather the applicable transitions that have the lowest specificity score, then stop once the specificty score increases, which is guaranteed to run in $O(n)$ time, where $n$ is the number of transition rules for a particular state.
+
+---
+
+## Validation and Error Handling
+
+The devkit intercepts and formats all ANTLR4 parser errors, throwing descriptive exceptions. You never have to write validation logic in your downstream compiler.
+
+* `VarphiGlobalTapeCountError`: Thrown if any line uses a different number of tapes than the first transition line. 
+* `VarphiTransitionInconsistentTapeCountError`: Thrown if a single rule attempts to read a different number of tape symbols than it writes.
+* `VarphiUndefinedVariableError`: Thrown if a variable is used in the write tuple without being bound in the read tuple first.
+* `VarphiUnknownSymbolError` & `VarphiUnknownDirectionError`: Lexer fallbacks for unrecognized tokens.
+
+---
+
+## Contributing
+
+When modifying the ANTLR4 grammar (`grammar/Varphi.g4`), ensure you regenerate the parser before running the test suite:
+
+1. Modify `.g4` file.
+2. Run `antlr4 -Dlanguage=Python3 grammar/Varphi.g4 -o src/varphi_devkit/parser/`
+3. Run the test suite: `pytest tests/`

varphi_devkit-3.0.0/README.md

@@ -0,0 +1,111 @@
+# The Varphi Compiler Development Kit
+
+This is the official frontend parsing and compiler development kit for the Varphi programming language.
+
+The devkit is a target-language-agnostic frontent that handles lexical analysis, syntax parsing, semantic validation, and intermediate representation (IR) generation. It is designed so that downstream developers can write backend compilers (e.g., Varphi-to-Python, Varphi-to-C, ...) without needing to worry about all the "dirty work" of compilers, like lexing and parsing.
+
+---
+
+## 📦 Installation
+
+Assuming you are using a standard Python environment or a modern manager like `uv`:
+
+```
+# For pip
+pip install varphi-devkit
+# For uv
+uv pip install varphi-devkit
+```
+
+---
+
+## Quick Start: Building a Downstream Compiler
+
+Building a Varphi compiler requires inheriting from the `VarphiCompiler` base class and implementing a single method: `_generate_compiled_program()`.
+
+```python
+from varphi_devkit import VarphiCompiler
+
+class VarphiToMyLangCompiler(VarphiCompiler):
+    
+    def _generate_compiled_program(self) -> str:
+        # By the time this method is called, the devkit has already parsed, validated, and sorted the Varphi source code. 
+        
+        # self.states: A set of all state names (strings) discovered in the code.
+        print(f"Total states: {len(self.states)}")
+        
+        # self.initial_state: The entry state (string).
+        print(f"Entry point: {self.initial_state}")
+        
+        # self._tape_count: The number of tapes in this machine (int).
+        print(f"Tape count: {self._tape_count}")
+
+        # self.ir: A dictionary mapping state names to a pre-sorted list of VarphiTransitions.
+        # The VarphiTransitions are sorted in non-decreasing order of specificity
+        for state_name, transitions in self.ir.items():
+            for t in transitions:
+                # Code generation logic goes here!
+                pass
+                
+        return "Compilation Complete!"  # You would return your compiled program here
+
+# Usage
+compiler = VarphiToMyLangCompiler()
+with open("machine.vp", "r") as f:
+    compiled_code = compiler.compile(f.read())
+```
+
+---
+
+## The Intermediate Representation (IR)
+
+The devkit translates raw `.vp` source text into a strictly typed IR. Every transition rule in the user's source code is mapped to a `VarphiTransition` object.
+
+Because downstream compilers receive this IR *after* the Devkit has validated it, it has already been totally validated, saving you development time/effort.
+
+### `VarphiTransition`
+
+```python
+@dataclass(frozen=True)
+class VarphiTransition:
+    current_state: str 
+    read_symbols: tuple[ReadWriteTupleElement, ...]  
+    next_state: str
+    write_symbols: tuple[ReadWriteTupleElement, ...] 
+    shift_directions: tuple[Direction, ...]        
+    line_number: int
+    specificity: tuple[int, int]  # (unique variables, total variables)
+```
+
+---
+
+## The Specificity Engine
+
+Varphi is a nondeterministic language with pattern matching. When multiple rules match a tape state, the machine must choose the "most specific" rule, or stochastically branch if there is a tie.
+
+The Devkit calculates a specificity score for every transition, accessible through the `specificity` of a `VarphiTransition` object. Its type is a two-element tuple, where the first element gives the number of unique variables in the transition rule and the second gives the total number of variables (including dupicates) in the transition rule. 
+
+Thus, a rule containing all literals scores lower (i.e., `(0, 0)`) than one containing variables. 
+
+Before calling your compiler's generation method, the devkit groups all transitions by state and sorts them in non-decreasing order of specificity. Downstream runtimes can simply iterate over a state's transitions, gather the applicable transitions that have the lowest specificity score, then stop once the specificty score increases, which is guaranteed to run in $O(n)$ time, where $n$ is the number of transition rules for a particular state.
+
+---
+
+## Validation and Error Handling
+
+The devkit intercepts and formats all ANTLR4 parser errors, throwing descriptive exceptions. You never have to write validation logic in your downstream compiler.
+
+* `VarphiGlobalTapeCountError`: Thrown if any line uses a different number of tapes than the first transition line. 
+* `VarphiTransitionInconsistentTapeCountError`: Thrown if a single rule attempts to read a different number of tape symbols than it writes.
+* `VarphiUndefinedVariableError`: Thrown if a variable is used in the write tuple without being bound in the read tuple first.
+* `VarphiUnknownSymbolError` & `VarphiUnknownDirectionError`: Lexer fallbacks for unrecognized tokens.
+
+---
+
+## Contributing
+
+When modifying the ANTLR4 grammar (`grammar/Varphi.g4`), ensure you regenerate the parser before running the test suite:
+
+1. Modify `.g4` file.
+2. Run `antlr4 -Dlanguage=Python3 grammar/Varphi.g4 -o src/varphi_devkit/parser/`
+3. Run the test suite: `pytest tests/`

varphi_devkit-3.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "varphi-devkit"
+version = "3.0.0"
+description = "A framework for building compilers, interpreters, and analysis tools for the Varphi language."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["antlr4-python3-runtime==4.13.2"]
+
+[[project.authors]]
+name = "Varphi"
+email = "support@varphi-lang.com"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "antlr4-tools>=0.2.2",
+    "black",
+    "pytest",
+]

varphi_devkit-2.0.6/pyproject.toml → varphi_devkit-3.0.0/pyproject.toml.orig

@@ -1,12 +1,12 @@
 [project]
 name = "varphi-devkit"
-version = "2.0.6"
+version = "3.0.0"
 description = "A framework for building compilers, interpreters, and analysis tools for the Varphi language."
 readme = "README.md"
 authors = [
     { name = "Varphi", email = "support@varphi-lang.com" }
 ]
-requires-python = ">=3.13"
+requires-python = ">=3.10"
 dependencies = [
     "antlr4-python3-runtime==4.13.2",
 ]
@@ -18,6 +18,6 @@ build-backend = "uv_build"
 [dependency-groups]
 dev = [
     "antlr4-tools>=0.2.2",
-    "black>=25.12.0",
-    "pytest>=9.0.2",
+    "black",
+    "pytest",
 ]

{varphi_devkit-2.0.6 → varphi_devkit-3.0.0}/src/varphi_devkit/__init__.py

@@ -6,17 +6,21 @@ This package handles the complexity of parsing, validation, and variable canonic
 convenient abstraction layer for implementing custom Varphi backends.
 
 **Core API:**
-- `VarphiCompiler`: The abstract base class you must subclass. Override `handle_transition` to process logic.
+- `VarphiCompiler`: The abstract base class you must subclass. Override `_generate_compiled_program()` to implement custom logic for a compiler.
 - `VarphiTransition`: A validated, canonicalized representation of a single transition line.
-
-**Constants:**
-- `BLANK`, `LEFT`, `RIGHT`, `STAY`: Primitives for tape operations.
-
-**Exceptions:**
-- `VarphiSyntaxError`: Base class for rich error reporting with source code context.
 """
 
-from .compiler import VarphiCompiler, VarphiTransition, BLANK, LEFT, RIGHT, STAY
+__version__ = "3.0.0"
+
+from .compiler import (
+    VarphiCompiler,
+    VarphiTransition,
+    Direction,
+    BuiltinSymbol,
+    Variable,
+    Character,
+    ReadWriteTupleElement,
+)
 from .exceptions import (
     VarphiSyntaxError,
     VarphiTransitionInconsistentTapeCountError,
@@ -27,10 +31,11 @@ from .exceptions import (
 __all__ = [
     "VarphiCompiler",
     "VarphiTransition",
-    "BLANK",
-    "LEFT",
-    "RIGHT",
-    "STAY",
+    "Direction",
+    "BuiltinSymbol",
+    "Variable",
+    "Character",
+    "ReadWriteTupleElement",
     "VarphiSyntaxError",
     "VarphiTransitionInconsistentTapeCountError",
     "VarphiGlobalTapeCountError",

varphi_devkit-3.0.0/src/varphi_devkit/compiler.py

@@ -0,0 +1,191 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+from collections import defaultdict
+from antlr4 import InputStream, CommonTokenStream, ParseTreeWalker
+
+from .parser import VarphiLexer, VarphiParser, VarphiListener
+from .models import (
+    ReadWriteTupleElement,
+    Character,
+    BuiltinSymbol,
+    Variable,
+    Direction,
+    VarphiTransition,
+)
+from .exceptions import (
+    VarphiErrorListener,
+    VarphiTransitionInconsistentTapeCountError,
+    VarphiGlobalTapeCountError,
+    VarphiUndefinedVariableError,
+    VarphiInvalidUnicodeError,
+    VarphiUnknownSymbolError,
+    VarphiUnknownDirectionError,
+)
+
+
+class VarphiCompiler(VarphiListener, ABC):
+    """
+    An abstract Varphi compiler and IR generator.
+
+    Concrete subclasses must implement `_generate_compiled_program()`.
+    When called, the subclass can safely access:
+        - self.states (set[str]): The names of all states in the user's source Varphi program
+        - self.initial_state (str): The name of the first state encountered.
+        - self.ir (dict[str, list[VarphiTransition]]): A map of states to their transitions, sorted by specificity score.
+    """
+
+    _tape_count: Optional[int]
+    _raw_transitions: list[VarphiTransition]
+
+    states: set[str]
+    initial_state: Optional[str]
+    ir: dict[str, list[VarphiTransition]]
+
+    def __init__(self):
+        """Initialize this compiler."""
+        self._tape_count = None
+        self._raw_transitions = []
+        self.states = set()
+        self.initial_state = None
+        self.ir = {}
+
+    @abstractmethod
+    def _generate_compiled_program(self) -> str:
+        """Generate the compiled program."""
+        pass
+
+    def compile(self, program: str) -> str:
+        """Compile a Varphi program."""
+        self._tape_count = None
+        self._raw_transitions = []
+        self.states = set()
+        self.initial_state = None
+        self.ir = {}
+
+        input_stream = InputStream(program)
+        error_listener = VarphiErrorListener()
+
+        lexer = VarphiLexer(input_stream)
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(error_listener)
+
+        token_stream = CommonTokenStream(lexer)
+        parser = VarphiParser(token_stream)
+        parser.removeErrorListeners()
+        parser.addErrorListener(error_listener)
+
+        tree = parser.program()
+        walker = ParseTreeWalker()
+        walker.walk(self, tree)
+
+        self._build_ir()
+
+        return self._generate_compiled_program()
+
+    def _build_ir(self) -> None:
+        """Groups parsed transitions by state and sorts them by specificity."""
+        grouped_transitions: defaultdict[str, list[VarphiTransition]] = defaultdict(
+            list
+        )
+        for transition in self._raw_transitions:
+            grouped_transitions[transition.current_state].append(transition)
+
+        for state, transitions in grouped_transitions.items():
+            transitions.sort(key=lambda transition: transition.specificity)
+            self.ir[state] = transitions
+
+    def enterTransition(self, ctx: VarphiParser.TransitionContext) -> None:
+        """Process and add a transition to the raw IR."""
+        current_state = ctx.current_state.getText()
+        next_state = ctx.next_state.getText()
+        self.states.add(current_state)
+        self.states.add(next_state)
+
+        if self.initial_state is None:
+            self.initial_state = current_state
+
+        next_variable_number = 0
+        variable_name_to_variable_object = {}
+
+        def extract_symbol(
+            symbol_ctx, variable_undefined_ok: bool = True
+        ) -> ReadWriteTupleElement:
+            nonlocal next_variable_number, variable_name_to_variable_object
+
+            if symbol_ctx.VARIABLE():
+                variable_name = symbol_ctx.VARIABLE().getText()
+                if variable_name in variable_name_to_variable_object:
+                    return variable_name_to_variable_object[variable_name]
+                if not variable_undefined_ok:
+                    raise VarphiUndefinedVariableError(symbol_ctx, variable_name)
+                variable_name_to_variable_object[variable_name] = Variable(
+                    next_variable_number
+                )
+                next_variable_number += 1
+                return variable_name_to_variable_object[variable_name]
+
+            if symbol_ctx.BLANK_KW():
+                return BuiltinSymbol.BLANK
+
+            if symbol_ctx.INT():
+                unicode_val = int(symbol_ctx.INT().getText())
+                if not (0 <= unicode_val <= 0x10FFFF):
+                    raise VarphiInvalidUnicodeError(symbol_ctx, unicode_val)
+                return Character(chr(unicode_val))
+
+            if symbol_ctx.CHAR_LITERAL():
+                # Strip the outer single quotes (e.g., "'a'" becomes "a")
+                text = symbol_ctx.CHAR_LITERAL().getText()[1:-1]
+                return Character(text)
+
+            raise VarphiUnknownSymbolError(symbol_ctx, symbol_ctx.getText())
+
+        def extract_direction(direction_ctx) -> Direction:
+            if direction_ctx.LEFT_KW():
+                return Direction.LEFT
+            if direction_ctx.RIGHT_KW():
+                return Direction.RIGHT
+            if direction_ctx.STAY_KW():
+                return Direction.STAY
+            raise VarphiUnknownDirectionError(direction_ctx, direction_ctx.getText())
+
+        read_ctx = ctx.read_symbols()
+        reads = tuple(extract_symbol(s) for s in read_ctx.symbol()) if read_ctx else ()
+
+        write_ctx = ctx.write_symbols()
+        writes = (
+            tuple(
+                extract_symbol(s, variable_undefined_ok=False)
+                for s in write_ctx.symbol()
+            )
+            if write_ctx
+            else ()
+        )
+
+        shift_ctx = ctx.shift_directions()
+        shifts = (
+            tuple(extract_direction(d) for d in shift_ctx.direction())
+            if shift_ctx
+            else ()
+        )
+
+        if len(writes) != len(reads) or len(shifts) != len(reads):
+            raise VarphiTransitionInconsistentTapeCountError(
+                ctx, len(reads), len(writes), len(shifts)
+            )
+
+        current_tape_count = len(reads)
+        if self._tape_count is None:
+            self._tape_count = current_tape_count
+        elif current_tape_count != self._tape_count:
+            raise VarphiGlobalTapeCountError(ctx, self._tape_count, current_tape_count)
+
+        transition = VarphiTransition(
+            current_state=current_state,
+            read_symbols=reads,
+            next_state=next_state,
+            write_symbols=writes,
+            shift_directions=shifts,
+            line_number=ctx.start.line,
+        )
+        self._raw_transitions.append(transition)

{varphi_devkit-2.0.6 → varphi_devkit-3.0.0}/src/varphi_devkit/exceptions.py

@@ -120,6 +120,38 @@ class VarphiUndefinedVariableError(VarphiSyntaxError):
         super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
 
 
+class VarphiInvalidSymbolLengthError(VarphiSyntaxError):
+    """Raised when an ID token used as a tape symbol is longer than one character."""
+
+    def __init__(self, ctx, symbol):
+        msg = f"invalid symbol '{symbol}': tape symbols must be exactly one character."
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
+class VarphiInvalidUnicodeError(VarphiSyntaxError):
+    """Raised when an integer token falls outside the valid unicode code point range."""
+
+    def __init__(self, ctx, value):
+        msg = f"invalid unicode code point '{value}': must be between 0 and 1114111 (0x10FFFF)."
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
+class VarphiUnknownSymbolError(VarphiSyntaxError):
+    """Raised when an unrecognized token type is encountered in a read/write tuple."""
+
+    def __init__(self, ctx, symbol_text):
+        msg = f"unknown symbol: '{symbol_text}' is not a valid tape symbol."
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
+class VarphiUnknownDirectionError(VarphiSyntaxError):
+    """Raised when an unrecognized token type is encountered in a shift tuple."""
+
+    def __init__(self, ctx, direction_text):
+        msg = f"unknown direction: '{direction_text}'. Must be LEFT, RIGHT, or STAY."
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
 class VarphiErrorListener(ErrorListener):
     """Custom ANTLR ErrorListener that converts syntax errors into VarphiSyntaxErrors."""
 

varphi_devkit-3.0.0/src/varphi_devkit/models.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+
+class ReadWriteTupleElement:
+    """Base class for all elements that can appear in the read or write tuple of a Varphi transition."""
+
+    pass
+
+
+@dataclass(frozen=True, eq=True)
+class Character(ReadWriteTupleElement):
+    """A concrete unicode character."""
+
+    value: str
+
+    def __post_init__(self):
+        if not isinstance(self.value, str) or len(self.value) != 1:
+            raise ValueError(
+                f"Character must be exactly 1 string character, got {self.value!r}"
+            )
+
+
+class BuiltinSymbol(ReadWriteTupleElement, Enum):
+    """A builtin Varphi symbol."""
+
+    BLANK = auto()
+
+
+@dataclass(frozen=True, eq=True)
+class Variable(ReadWriteTupleElement):
+    """A variable ID."""
+
+    id: int
+
+
+class Direction(Enum):
+    """A head direction."""
+
+    LEFT = auto()
+    RIGHT = auto()
+    STAY = auto()
+
+
+@dataclass(frozen=True)
+class VarphiTransition:
+    """A transition (logically, a single line) in a Varphi program."""
+
+    current_state: str
+    read_symbols: tuple[ReadWriteTupleElement, ...]
+    next_state: str
+    write_symbols: tuple[ReadWriteTupleElement, ...]
+    shift_directions: tuple[Direction, ...]
+    line_number: int
+    specificity: tuple[int, int] = field(
+        init=False
+    )  # (unique variables, total variables)
+
+    def __post_init__(self):
+        variables = [s for s in self.read_symbols if isinstance(s, Variable)]
+        unique_variables = len(set(variables))
+        total_variables = len(variables)
+
+        # Because the dataclass is frozen, we must bypass normal assignment
+        object.__setattr__(self, "specificity", (unique_variables, total_variables))

varphi_devkit-3.0.0/src/varphi_devkit/parser/Varphi.interp

@@ -0,0 +1,49 @@
+token literal names:
+null
+'('
+')'
+','
+null
+null
+'LEFT'
+'RIGHT'
+'STAY'
+'BLANK'
+null
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+LPAREN
+RPAREN
+COMMA
+CHAR_LITERAL
+VARIABLE
+LEFT_KW
+RIGHT_KW
+STAY_KW
+BLANK_KW
+INT
+ID
+COMMENT
+MULTI_COMMENT
+WHITESPACE
+NEWLINE
+
+rule names:
+program
+transition
+read_symbols
+write_symbols
+shift_directions
+state_id
+symbol
+direction
+
+
+atn:
+[4, 1, 15, 88, 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, 1, 0, 5, 0, 18, 8, 0, 10, 0, 12, 0, 21, 9, 0, 1, 0, 1, 0, 4, 0, 25, 8, 0, 11, 0, 12, 0, 26, 1, 0, 5, 0, 30, 8, 0, 10, 0, 12, 0, 33, 9, 0, 1, 0, 5, 0, 36, 8, 0, 10, 0, 12, 0, 39, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 53, 8, 2, 10, 2, 12, 2, 56, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 64, 8, 3, 10, 3, 12, 3, 67, 9, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 75, 8, 4, 10, 4, 12, 4, 78, 9, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 0, 0, 8, 0, 2, 4, 6, 8, 10, 12, 14, 0, 3, 1, 0, 6, 11, 2, 0, 4, 5, 9, 10, 1, 0, 6, 8, 86, 0, 19, 1, 0, 0, 0, 2, 42, 1, 0, 0, 0, 4, 48, 1, 0, 0, 0, 6, 59, 1, 0, 0, 0, 8, 70, 1, 0, 0, 0, 10, 81, 1, 0, 0, 0, 12, 83, 1, 0, 0, 0, 14, 85, 1, 0, 0, 0, 16, 18, 5, 15, 0, 0, 17, 16, 1, 0, 0, 0, 18, 21, 1, 0, 0, 0, 19, 17, 1, 0, 0, 0, 19, 20, 1, 0, 0, 0, 20, 22, 1, 0, 0, 0, 21, 19, 1, 0, 0, 0, 22, 31, 3, 2, 1, 0, 23, 25, 5, 15, 0, 0, 24, 23, 1, 0, 0, 0, 25, 26, 1, 0, 0, 0, 26, 24, 1, 0, 0, 0, 26, 27, 1, 0, 0, 0, 27, 28, 1, 0, 0, 0, 28, 30, 3, 2, 1, 0, 29, 24, 1, 0, 0, 0, 30, 33, 1, 0, 0, 0, 31, 29, 1, 0, 0, 0, 31, 32, 1, 0, 0, 0, 32, 37, 1, 0, 0, 0, 33, 31, 1, 0, 0, 0, 34, 36, 5, 15, 0, 0, 35, 34, 1, 0, 0, 0, 36, 39, 1, 0, 0, 0, 37, 35, 1, 0, 0, 0, 37, 38, 1, 0, 0, 0, 38, 40, 1, 0, 0, 0, 39, 37, 1, 0, 0, 0, 40, 41, 5, 0, 0, 1, 41, 1, 1, 0, 0, 0, 42, 43, 3, 10, 5, 0, 43, 44, 3, 4, 2, 0, 44, 45, 3, 10, 5, 0, 45, 46, 3, 6, 3, 0, 46, 47, 3, 8, 4, 0, 47, 3, 1, 0, 0, 0, 48, 49, 5, 1, 0, 0, 49, 54, 3, 12, 6, 0, 50, 51, 5, 3, 0, 0, 51, 53, 3, 12, 6, 0, 52, 50, 1, 0, 0, 0, 53, 56, 1, 0, 0, 0, 54, 52, 1, 0, 0, 0, 54, 55, 1, 0, 0, 0, 55, 57, 1, 0, 0, 0, 56, 54, 1, 0, 0, 0, 57, 58, 5, 2, 0, 0, 58, 5, 1, 0, 0, 0, 59, 60, 5, 1, 0, 0, 60, 65, 3, 12, 6, 0, 61, 62, 5, 3, 0, 0, 62, 64, 3, 12, 6, 0, 63, 61, 1, 0, 0, 0, 64, 67, 1, 0, 0, 0, 65, 63, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 68, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 68, 69, 5, 2, 0, 0, 69, 7, 1, 0, 0, 0, 70, 71, 5, 1, 0, 0, 71, 76, 3, 14, 7, 0, 72, 73, 5, 3, 0, 0, 73, 75, 3, 14, 7, 0, 74, 72, 1, 0, 0, 0, 75, 78, 1, 0, 0, 0, 76, 74, 1, 0, 0, 0, 76, 77, 1, 0, 0, 0, 77, 79, 1, 0, 0, 0, 78, 76, 1, 0, 0, 0, 79, 80, 5, 2, 0, 0, 80, 9, 1, 0, 0, 0, 81, 82, 7, 0, 0, 0, 82, 11, 1, 0, 0, 0, 83, 84, 7, 1, 0, 0, 84, 13, 1, 0, 0, 0, 85, 86, 7, 2, 0, 0, 86, 15, 1, 0, 0, 0, 7, 19, 26, 31, 37, 54, 65, 76]