Chess Challenge submission by Tome1

README.md

@@ -0,0 +1,26 @@
+---
+library_name: transformers
+tags:
+- chess
+- llm-course
+- chess-challenge
+license: mit
+---
+
+# chess-tomin-v3
+
+Chess model submitted to the LLM Course Chess Challenge.
+
+## Submission Info
+
+- **Submitted by**: [Tome1](https://huggingface.co/Tome1)
+- **Parameters**: 631,424
+- **Organization**: LLM-course
+
+## Model Details
+
+- **Architecture**: Chess Transformer (GPT-style)
+- **Vocab size**: 543
+- **Embedding dim**: 128
+- **Layers**: 3
+- **Heads**: 4

config.json

@@ -0,0 +1,20 @@
+{
+  "architectures": [
+    "ChessForCausalLM"
+  ],
+  "bos_token_id": 1,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "chess_transformer",
+  "n_ctx": 512,
+  "n_embd": 128,
+  "n_head": 4,
+  "n_inner": 384,
+  "n_layer": 3,
+  "pad_token_id": 0,
+  "tie_weights": true,
+  "transformers_version": "4.57.4",
+  "vocab_size": 543
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77617e4a08e4bf111c0745f35b287438d63accd689a351cd695db4099926cca1
+size 2529072

special_tokens_map.json

@@ -0,0 +1,6 @@
+{
+  "bos_token": "[BOS]",
+  "eos_token": "[EOS]",
+  "pad_token": "[PAD]",
+  "unk_token": "[UNK]"
+}

tokenizer.py

@@ -0,0 +1,192 @@
+"""
+Custom Chess Tokenizer for the Chess Challenge.
+
+This tokenizer treats each move as a single token using the extended UCI notation
+from the Lichess dataset (e.g., WPe2e4, BNg8f6).
+
+The dataset format uses:
+- W/B prefix for White/Black
+- Piece letter: P=Pawn, N=Knight, B=Bishop, R=Rook, Q=Queen, K=King
+- Source and destination squares (e.g., e2e4)
+- Special suffixes: (x)=capture, (+)=check, (+*)=checkmate, (o)/(O)=castling
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+from transformers import PreTrainedTokenizer
+
+
+
+
+
+"""
+Custom Chess Tokenizer (Split Move Version).
+
+Splits moves into 3 components:
+1. Piece (e.g., "WP")
+2. From Square (e.g., "e2")
+3. To Square (e.g., "e4")
+"""
+
+
+
+class ChessTokenizer(PreTrainedTokenizer):
+    model_input_names = ["input_ids", "attention_mask"]
+    
+    # Special tokens
+    PAD_TOKEN = "[PAD]"
+    BOS_TOKEN = "[BOS]" # Beginning of Sequence (Start of Game)
+    EOS_TOKEN = "[EOS]" # End of Sequence (End of Game)
+    UNK_TOKEN = "[UNK]"
+
+    vocab_files_names = {
+        "vocab_file": "vocab.json"
+    }
+    
+    def __init__(
+        self,
+        vocab_file: Optional[str] = None,
+        vocab: Optional[Dict[str, int]] = None,
+        **kwargs,
+    ):
+        self._pad_token = self.PAD_TOKEN
+        self._bos_token = self.BOS_TOKEN
+        self._eos_token = self.EOS_TOKEN
+        self._unk_token = self.UNK_TOKEN
+        
+        # Clean kwargs to avoid conflicts
+        kwargs.pop("pad_token", None)
+        kwargs.pop("bos_token", None)
+        kwargs.pop("eos_token", None)
+        kwargs.pop("unk_token", None)
+
+        self.vocab_file = vocab_file
+        
+        if vocab is not None:
+            self._vocab = vocab
+        elif vocab_file is not None and os.path.exists(vocab_file):
+            with open(vocab_file, "r", encoding="utf-8") as f:
+                self._vocab = json.load(f)
+        else:
+            self._vocab = self._create_default_vocab()
+            
+        self._ids_to_tokens = {v: k for k, v in self._vocab.items()}
+        
+        super().__init__(
+            pad_token=self._pad_token,
+            bos_token=self._bos_token,
+            eos_token=self._eos_token,
+            unk_token=self._unk_token,
+            **kwargs,
+        )
+
+    def _create_default_vocab(self) -> Dict[str, int]:
+        """Creates basic vocab. Use build_vocab_from_dataset for full vocab."""
+        # 4 Special + 12 Pieces + 64 Squares = 80 tokens total
+        special = [self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN]
+        vocab = {t: i for i, t in enumerate(special)}
+        return vocab
+
+    @property
+    def vocab_size(self) -> int:
+        return len(self._vocab)
+
+    def get_vocab(self) -> Dict[str, int]:
+        return dict(self._vocab)
+
+    def _tokenize(self, text: str) -> List[str]:
+        """
+        Splits text "WPe2e4 BNg8f6" into ["WP", "e2", "e4", "BN", "g8", "f6"]
+        """
+        tokens = []
+        # Split by space to get individual moves first
+        raw_moves = text.strip().split()
+
+        
+        for move in raw_moves:
+            # Check length to ensure it's a valid move string
+            if len(move) >= 6:
+                # Part 1: Player + Piece (Indices 0-2, e.g., "WP")
+                tokens.append(move[:2])
+                
+                # Part 2: Start Square (Indices 2-4, e.g., "e2")
+                tokens.append(move[2:4])
+                
+                # Part 3: End Square (Indices 4-6, e.g., "e4")
+                tokens.append(move[4:])
+
+
+
+            else:
+                tokens.append(self.UNK_TOKEN)
+
+
+        return tokens
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self._vocab.get(token, self._vocab.get(self.UNK_TOKEN))
+
+    def _convert_id_to_token(self, index: int) -> str:
+        return self._ids_to_tokens.get(index, self.UNK_TOKEN)
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        """
+        Reconstructs the move string. 
+        Note: This simply joins them. You might need custom logic 
+        if you want to strictly recreate 'WPe2e4' from ['WP','e2','e4'].
+        """
+        return " ".join(t for t in tokens if t not in [
+            self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN
+        ])
+
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> tuple:
+        if not os.path.isdir(save_directory):
+            os.makedirs(save_directory, exist_ok=True)
+        
+        vocab_file = os.path.join(
+            save_directory, 
+            (filename_prefix + "-" if filename_prefix else "") + "vocab.json"
+        )
+        
+        with open(vocab_file, "w", encoding="utf-8") as f:
+            json.dump(self._vocab, f, ensure_ascii=False, indent=2)
+            
+        return (vocab_file,)
+
+    @classmethod
+    def build_vocab_from_dataset(cls, dataset_name="dlouapre/lichess_2025-01_1M", split="train", max_samples=10000):
+        """Scans dataset to find all unique pieces and squares."""
+        from datasets import load_dataset
+        dataset = load_dataset(dataset_name, split=split, streaming=True)
+        
+        pieces = set()
+        squares = set()
+        endings = set()
+        
+        print("Building vocabulary...")
+        count = 0
+        for example in dataset:
+            moves = example["text"].split()
+            for move in moves:
+                if len(move) >= 6:
+                    pieces.add(move[:2])    # WP, BN, etc.
+                    squares.add(move[2:4])  # e2
+                    squares.add(move[4:])  # e4
+
+
+            count += 1
+            if count >= max_samples:
+                break
+
+        # Combine into vocab structure
+        special = [cls.PAD_TOKEN, cls.BOS_TOKEN, cls.EOS_TOKEN, cls.UNK_TOKEN]
+        all_tokens = special + sorted(list(pieces)) + sorted(list(endings)) + sorted(list(squares))
+        
+        vocab = {token: idx for idx, token in enumerate(all_tokens)}
+        return cls(vocab=vocab)

tokenizer_config.json

@@ -0,0 +1,44 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[BOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[EOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "[BOS]",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "[EOS]",
+  "extra_special_tokens": {},
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "tokenizer_class": "ChessTokenizer",
+  "unk_token": "[UNK]"
+}

vocab.json

@@ -0,0 +1,545 @@
+{
+  "[PAD]": 0,
+  "[BOS]": 1,
+  "[EOS]": 2,
+  "[UNK]": 3,
+  "BB": 4,
+  "BK": 5,
+  "BN": 6,
+  "BP": 7,
+  "BQ": 8,
+  "BR": 9,
+  "WB": 10,
+  "WK": 11,
+  "WN": 12,
+  "WP": 13,
+  "WQ": 14,
+  "WR": 15,
+  "a1": 16,
+  "a1(+)": 17,
+  "a1(+*)": 18,
+  "a1(+*Q)": 19,
+  "a1(+*R)": 20,
+  "a1(+N)": 21,
+  "a1(+Q)": 22,
+  "a1(B)": 23,
+  "a1(N)": 24,
+  "a1(Q)": 25,
+  "a1(x)": 26,
+  "a1(x+)": 27,
+  "a1(x+Q)": 28,
+  "a1(xQ)": 29,
+  "a2": 30,
+  "a2(+)": 31,
+  "a2(+*)": 32,
+  "a2(x)": 33,
+  "a2(x+)": 34,
+  "a2(x+*)": 35,
+  "a3": 36,
+  "a3(+)": 37,
+  "a3(+*)": 38,
+  "a3(x)": 39,
+  "a3(x+)": 40,
+  "a3(x+*)": 41,
+  "a3(xE)": 42,
+  "a4": 43,
+  "a4(+)": 44,
+  "a4(+*)": 45,
+  "a4(x)": 46,
+  "a4(x+)": 47,
+  "a4(x+*)": 48,
+  "a5": 49,
+  "a5(+)": 50,
+  "a5(+*)": 51,
+  "a5(x)": 52,
+  "a5(x+)": 53,
+  "a5(x+*)": 54,
+  "a6": 55,
+  "a6(+)": 56,
+  "a6(+*)": 57,
+  "a6(x)": 58,
+  "a6(x+)": 59,
+  "a6(x+*)": 60,
+  "a6(xE)": 61,
+  "a6(xE+)": 62,
+  "a7": 63,
+  "a7(+)": 64,
+  "a7(+*)": 65,
+  "a7(x)": 66,
+  "a7(x+)": 67,
+  "a7(x+*)": 68,
+  "a8": 69,
+  "a8(+)": 70,
+  "a8(+*)": 71,
+  "a8(+*Q)": 72,
+  "a8(+Q)": 73,
+  "a8(Q)": 74,
+  "a8(R)": 75,
+  "a8(x)": 76,
+  "a8(x+)": 77,
+  "a8(x+*)": 78,
+  "a8(xQ)": 79,
+  "b1": 80,
+  "b1(+)": 81,
+  "b1(+*)": 82,
+  "b1(+*Q)": 83,
+  "b1(+N)": 84,
+  "b1(+Q)": 85,
+  "b1(N)": 86,
+  "b1(Q)": 87,
+  "b1(R)": 88,
+  "b1(x)": 89,
+  "b1(x+)": 90,
+  "b1(x+*)": 91,
+  "b1(x+Q)": 92,
+  "b1(xQ)": 93,
+  "b2": 94,
+  "b2(+)": 95,
+  "b2(+*)": 96,
+  "b2(x)": 97,
+  "b2(x+)": 98,
+  "b2(x+*)": 99,
+  "b3": 100,
+  "b3(+)": 101,
+  "b3(+*)": 102,
+  "b3(x)": 103,
+  "b3(x+)": 104,
+  "b3(x+*)": 105,
+  "b3(xE)": 106,
+  "b3(xE+)": 107,
+  "b4": 108,
+  "b4(+)": 109,
+  "b4(+*)": 110,
+  "b4(x)": 111,
+  "b4(x+)": 112,
+  "b4(x+*)": 113,
+  "b5": 114,
+  "b5(+)": 115,
+  "b5(+*)": 116,
+  "b5(x)": 117,
+  "b5(x+)": 118,
+  "b5(x+*)": 119,
+  "b6": 120,
+  "b6(+)": 121,
+  "b6(+*)": 122,
+  "b6(x)": 123,
+  "b6(x+)": 124,
+  "b6(x+*)": 125,
+  "b6(xE)": 126,
+  "b7": 127,
+  "b7(+)": 128,
+  "b7(+*)": 129,
+  "b7(x)": 130,
+  "b7(x+)": 131,
+  "b7(x+*)": 132,
+  "b8": 133,
+  "b8(+)": 134,
+  "b8(+*)": 135,
+  "b8(+*Q)": 136,
+  "b8(+Q)": 137,
+  "b8(Q)": 138,
+  "b8(R)": 139,
+  "b8(x)": 140,
+  "b8(x+)": 141,
+  "b8(x+*)": 142,
+  "b8(x+Q)": 143,
+  "b8(xQ)": 144,
+  "c1": 145,
+  "c1(+)": 146,
+  "c1(+*)": 147,
+  "c1(+*Q)": 148,
+  "c1(+N)": 149,
+  "c1(+Q)": 150,
+  "c1(+R)": 151,
+  "c1(O)": 152,
+  "c1(O+)": 153,
+  "c1(O+*)": 154,
+  "c1(Q)": 155,
+  "c1(x)": 156,
+  "c1(x+)": 157,
+  "c1(x+*)": 158,
+  "c1(x+*Q)": 159,
+  "c1(x+Q)": 160,
+  "c1(xN)": 161,
+  "c1(xQ)": 162,
+  "c2": 163,
+  "c2(+)": 164,
+  "c2(+*)": 165,
+  "c2(x)": 166,
+  "c2(x+)": 167,
+  "c2(x+*)": 168,
+  "c3": 169,
+  "c3(+)": 170,
+  "c3(+*)": 171,
+  "c3(x)": 172,
+  "c3(x+)": 173,
+  "c3(x+*)": 174,
+  "c3(xE)": 175,
+  "c3(xE+)": 176,
+  "c4": 177,
+  "c4(+)": 178,
+  "c4(+*)": 179,
+  "c4(x)": 180,
+  "c4(x+)": 181,
+  "c4(x+*)": 182,
+  "c5": 183,
+  "c5(+)": 184,
+  "c5(+*)": 185,
+  "c5(x)": 186,
+  "c5(x+)": 187,
+  "c5(x+*)": 188,
+  "c6": 189,
+  "c6(+)": 190,
+  "c6(+*)": 191,
+  "c6(x)": 192,
+  "c6(x+)": 193,
+  "c6(x+*)": 194,
+  "c6(xE)": 195,
+  "c6(xE+)": 196,
+  "c7": 197,
+  "c7(+)": 198,
+  "c7(+*)": 199,
+  "c7(x)": 200,
+  "c7(x+)": 201,
+  "c7(x+*)": 202,
+  "c8": 203,
+  "c8(+)": 204,
+  "c8(+*)": 205,
+  "c8(+*Q)": 206,
+  "c8(+Q)": 207,
+  "c8(O)": 208,
+  "c8(O+)": 209,
+  "c8(Q)": 210,
+  "c8(x)": 211,
+  "c8(x+)": 212,
+  "c8(x+*)": 213,
+  "c8(x+Q)": 214,
+  "c8(xQ)": 215,
+  "d1": 216,
+  "d1(+)": 217,
+  "d1(+*)": 218,
+  "d1(+*Q)": 219,
+  "d1(+Q)": 220,
+  "d1(Q)": 221,
+  "d1(x)": 222,
+  "d1(x+)": 223,
+  "d1(x+*)": 224,
+  "d1(x+Q)": 225,
+  "d1(xQ)": 226,
+  "d2": 227,
+  "d2(+)": 228,
+  "d2(+*)": 229,
+  "d2(x)": 230,
+  "d2(x+)": 231,
+  "d2(x+*)": 232,
+  "d3": 233,
+  "d3(+)": 234,
+  "d3(+*)": 235,
+  "d3(x)": 236,
+  "d3(x+)": 237,
+  "d3(x+*)": 238,
+  "d3(xE)": 239,
+  "d4": 240,
+  "d4(+)": 241,
+  "d4(+*)": 242,
+  "d4(x)": 243,
+  "d4(x+)": 244,
+  "d4(x+*)": 245,
+  "d5": 246,
+  "d5(+)": 247,
+  "d5(+*)": 248,
+  "d5(x)": 249,
+  "d5(x+)": 250,
+  "d5(x+*)": 251,
+  "d6": 252,
+  "d6(+)": 253,
+  "d6(+*)": 254,
+  "d6(x)": 255,
+  "d6(x+)": 256,
+  "d6(x+*)": 257,
+  "d6(xE)": 258,
+  "d7": 259,
+  "d7(+)": 260,
+  "d7(+*)": 261,
+  "d7(x)": 262,
+  "d7(x+)": 263,
+  "d7(x+*)": 264,
+  "d8": 265,
+  "d8(+)": 266,
+  "d8(+*)": 267,
+  "d8(+Q)": 268,
+  "d8(Q)": 269,
+  "d8(R)": 270,
+  "d8(x)": 271,
+  "d8(x+)": 272,
+  "d8(x+*)": 273,
+  "d8(x+Q)": 274,
+  "d8(xQ)": 275,
+  "e1": 276,
+  "e1(+)": 277,
+  "e1(+*)": 278,
+  "e1(+*Q)": 279,
+  "e1(+*R)": 280,
+  "e1(+Q)": 281,
+  "e1(Q)": 282,
+  "e1(x)": 283,
+  "e1(x+)": 284,
+  "e1(x+*)": 285,
+  "e1(x+Q)": 286,
+  "e1(xQ)": 287,
+  "e2": 288,
+  "e2(+)": 289,
+  "e2(+*)": 290,
+  "e2(x)": 291,
+  "e2(x+)": 292,
+  "e2(x+*)": 293,
+  "e3": 294,
+  "e3(+)": 295,
+  "e3(+*)": 296,
+  "e3(x)": 297,
+  "e3(x+)": 298,
+  "e3(x+*)": 299,
+  "e3(xE)": 300,
+  "e3(xE+)": 301,
+  "e4": 302,
+  "e4(+)": 303,
+  "e4(+*)": 304,
+  "e4(x)": 305,
+  "e4(x+)": 306,
+  "e4(x+*)": 307,
+  "e5": 308,
+  "e5(+)": 309,
+  "e5(+*)": 310,
+  "e5(x)": 311,
+  "e5(x+)": 312,
+  "e5(x+*)": 313,
+  "e6": 314,
+  "e6(+)": 315,
+  "e6(+*)": 316,
+  "e6(x)": 317,
+  "e6(x+)": 318,
+  "e6(x+*)": 319,
+  "e6(xE)": 320,
+  "e6(xE+)": 321,
+  "e7": 322,
+  "e7(+)": 323,
+  "e7(+*)": 324,
+  "e7(x)": 325,
+  "e7(x+)": 326,
+  "e7(x+*)": 327,
+  "e8": 328,
+  "e8(+)": 329,
+  "e8(+*)": 330,
+  "e8(+*Q)": 331,
+  "e8(+N)": 332,
+  "e8(+Q)": 333,
+  "e8(Q)": 334,
+  "e8(R)": 335,
+  "e8(x)": 336,
+  "e8(x+)": 337,
+  "e8(x+*)": 338,
+  "e8(x+*Q)": 339,
+  "e8(x+Q)": 340,
+  "e8(x+R)": 341,
+  "e8(xQ)": 342,
+  "f1": 343,
+  "f1(+)": 344,
+  "f1(+*)": 345,
+  "f1(+*Q)": 346,
+  "f1(+*R)": 347,
+  "f1(+N)": 348,
+  "f1(+Q)": 349,
+  "f1(B)": 350,
+  "f1(Q)": 351,
+  "f1(R)": 352,
+  "f1(x)": 353,
+  "f1(x+)": 354,
+  "f1(x+*)": 355,
+  "f1(x+N)": 356,
+  "f1(x+Q)": 357,
+  "f1(xQ)": 358,
+  "f2": 359,
+  "f2(+)": 360,
+  "f2(+*)": 361,
+  "f2(x)": 362,
+  "f2(x+)": 363,
+  "f2(x+*)": 364,
+  "f3": 365,
+  "f3(+)": 366,
+  "f3(+*)": 367,
+  "f3(x)": 368,
+  "f3(x+)": 369,
+  "f3(x+*)": 370,
+  "f3(xE)": 371,
+  "f3(xE+)": 372,
+  "f4": 373,
+  "f4(+)": 374,
+  "f4(+*)": 375,
+  "f4(x)": 376,
+  "f4(x+)": 377,
+  "f4(x+*)": 378,
+  "f5": 379,
+  "f5(+)": 380,
+  "f5(+*)": 381,
+  "f5(x)": 382,
+  "f5(x+)": 383,
+  "f5(x+*)": 384,
+  "f6": 385,
+  "f6(+)": 386,
+  "f6(+*)": 387,
+  "f6(x)": 388,
+  "f6(x+)": 389,
+  "f6(x+*)": 390,
+  "f6(xE)": 391,
+  "f6(xE+)": 392,
+  "f7": 393,
+  "f7(+)": 394,
+  "f7(+*)": 395,
+  "f7(x)": 396,
+  "f7(x+)": 397,
+  "f7(x+*)": 398,
+  "f8": 399,
+  "f8(+)": 400,
+  "f8(+*)": 401,
+  "f8(+*Q)": 402,
+  "f8(+Q)": 403,
+  "f8(+R)": 404,
+  "f8(Q)": 405,
+  "f8(x)": 406,
+  "f8(x+)": 407,
+  "f8(x+*)": 408,
+  "f8(x+Q)": 409,
+  "f8(xN)": 410,
+  "f8(xQ)": 411,
+  "g1": 412,
+  "g1(+)": 413,
+  "g1(+*)": 414,
+  "g1(+*Q)": 415,
+  "g1(+Q)": 416,
+  "g1(B)": 417,
+  "g1(Q)": 418,
+  "g1(o)": 419,
+  "g1(o+)": 420,
+  "g1(o+*)": 421,
+  "g1(x)": 422,
+  "g1(x+)": 423,
+  "g1(x+*)": 424,
+  "g1(x+Q)": 425,
+  "g1(xQ)": 426,
+  "g2": 427,
+  "g2(+)": 428,
+  "g2(+*)": 429,
+  "g2(x)": 430,
+  "g2(x+)": 431,
+  "g2(x+*)": 432,
+  "g3": 433,
+  "g3(+)": 434,
+  "g3(+*)": 435,
+  "g3(x)": 436,
+  "g3(x+)": 437,
+  "g3(x+*)": 438,
+  "g3(xE)": 439,
+  "g3(xE+)": 440,
+  "g4": 441,
+  "g4(+)": 442,
+  "g4(+*)": 443,
+  "g4(x)": 444,
+  "g4(x+)": 445,
+  "g4(x+*)": 446,
+  "g5": 447,
+  "g5(+)": 448,
+  "g5(+*)": 449,
+  "g5(x)": 450,
+  "g5(x+)": 451,
+  "g5(x+*)": 452,
+  "g6": 453,
+  "g6(+)": 454,
+  "g6(+*)": 455,
+  "g6(x)": 456,
+  "g6(x+)": 457,
+  "g6(x+*)": 458,
+  "g6(xE)": 459,
+  "g6(xE+)": 460,
+  "g7": 461,
+  "g7(+)": 462,
+  "g7(+*)": 463,
+  "g7(x)": 464,
+  "g7(x+)": 465,
+  "g7(x+*)": 466,
+  "g8": 467,
+  "g8(+)": 468,
+  "g8(+*)": 469,
+  "g8(+N)": 470,
+  "g8(+Q)": 471,
+  "g8(N)": 472,
+  "g8(Q)": 473,
+  "g8(o)": 474,
+  "g8(o+)": 475,
+  "g8(x)": 476,
+  "g8(x+)": 477,
+  "g8(x+*)": 478,
+  "g8(x+Q)": 479,
+  "h1": 480,
+  "h1(+)": 481,
+  "h1(+*)": 482,
+  "h1(+*Q)": 483,
+  "h1(+Q)": 484,
+  "h1(Q)": 485,
+  "h1(x)": 486,
+  "h1(x+)": 487,
+  "h1(x+*)": 488,
+  "h1(x+Q)": 489,
+  "h1(xQ)": 490,
+  "h2": 491,
+  "h2(+)": 492,
+  "h2(+*)": 493,
+  "h2(x)": 494,
+  "h2(x+)": 495,
+  "h2(x+*)": 496,
+  "h3": 497,
+  "h3(+)": 498,
+  "h3(+*)": 499,
+  "h3(x)": 500,
+  "h3(x+)": 501,
+  "h3(x+*)": 502,
+  "h3(xE)": 503,
+  "h4": 504,
+  "h4(+)": 505,
+  "h4(+*)": 506,
+  "h4(x)": 507,
+  "h4(x+)": 508,
+  "h4(x+*)": 509,
+  "h5": 510,
+  "h5(+)": 511,
+  "h5(+*)": 512,
+  "h5(x)": 513,
+  "h5(x+)": 514,
+  "h5(x+*)": 515,
+  "h6": 516,
+  "h6(+)": 517,
+  "h6(+*)": 518,
+  "h6(x)": 519,
+  "h6(x+)": 520,
+  "h6(x+*)": 521,
+  "h6(xE)": 522,
+  "h6(xE+)": 523,
+  "h7": 524,
+  "h7(+)": 525,
+  "h7(+*)": 526,
+  "h7(x)": 527,
+  "h7(x+)": 528,
+  "h7(x+*)": 529,
+  "h8": 530,
+  "h8(+)": 531,
+  "h8(+*)": 532,
+  "h8(+*Q)": 533,
+  "h8(+*R)": 534,
+  "h8(+Q)": 535,
+  "h8(+R)": 536,
+  "h8(Q)": 537,
+  "h8(R)": 538,
+  "h8(x)": 539,
+  "h8(x+)": 540,
+  "h8(x+*)": 541,
+  "h8(xQ)": 542
+}