diff --git a/README.md b/README.md index 59a3efc..43e75e4 100644 --- a/README.md +++ b/README.md @@ -1 +1,11 @@ -**Hello world!!!** +# PD V3 Processing + +- **Inputs:** Treated feature dictionaries per model from pre-processing. +- **Outputs:** Raw and isotonic PD scores for models A/B plus model T probability. +- **Artifacts:** Model binaries located under `models/` (XGBoost + isotonic joblib files). +- **Tests:** `python -m unittest sequence-3.pd_v3_processing.test_block`. +- **Signature:** Sequence-3 convention: `__main__` must keep an explicit typed parameter list covering every input (int/float/str) and build the record from those args before scoring; keep aligned with the block schemas. + +## Schema notes + +- `request_schema.json` and `response_schema.json` for this block are frozen. They describe arrays of `{name, value}` dicts (no nested dict-of-dicts), so that structure must be preserved—do not switch these schemas to dict-of-dicts or object-of-dicts even as the block code evolves. Arrays-of-dicts are still allowed where schematically appropriate. diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..d3d26ed --- /dev/null +++ b/__init__.py @@ -0,0 +1 @@ +__all__ = ["__main__"] diff --git a/block.py b/block.py index 3b227f9..f5c015e 100644 --- a/block.py +++ b/block.py @@ -1,21 +1,422 @@ -@flowx_block -def example_function(request: dict) -> dict: +import json +import logging +from functools import lru_cache +from pathlib import Path +from typing import Any, Dict, List, Tuple - # Processing logic here... +import joblib +import numpy as np +import pandas as pd +import xgboost as xgb +from pandas.api.types import ( + is_bool_dtype, + is_categorical_dtype, + is_float_dtype, + is_integer_dtype, + is_object_dtype, +) - return { - "meta_info": [ - { - "name": "created_date", - "type": "string", - "value": "2024-11-05" - } - ], - "fields": [ - { - "name": "", - "type": "", - "value": "" - } - ] - } +logger = logging.getLogger(__name__) + +# --------------------------------------------------------------------------- +# Paths & constants +# --------------------------------------------------------------------------- + +try: + BASE_DIR = Path(__file__).resolve().parent +except NameError: + # Fallback for environments where __file__ is not defined (e.g. some REPLs / notebooks) + BASE_DIR = Path.cwd() + +A_MODEL_PATH = BASE_DIR / "xgboost_model_A.joblib" +A_CATEGORY_ORDERS_PATH = BASE_DIR / "category_orders_train_A.json" + +B_MODEL_PATH = BASE_DIR / "xgboost_model_B.joblib" +B_CATEGORY_ORDERS_PATH = BASE_DIR / "category_orders_train_B.json" + +T_MODEL_PATH = BASE_DIR / "xgboost_model_T.joblib" +T_CATEGORY_ORDERS_PATH = BASE_DIR / "category_orders_train_T.json" + + +# --------------------------------------------------------------------------- +# Loaders +# --------------------------------------------------------------------------- + +def _load_category_orders(path: Path) -> Dict[str, Any]: + """Load category orders JSON from disk.""" + with open(path, "r") as f: + return json.load(f) + + +@lru_cache(maxsize=1) +def _load_a_model(): + """Load and cache model A.""" + logger.info("Loading model A from %s", A_MODEL_PATH) + return joblib.load(A_MODEL_PATH) + + +@lru_cache(maxsize=1) +def _load_b_model(): + """Load and cache model B.""" + logger.info("Loading model B from %s", B_MODEL_PATH) + return joblib.load(B_MODEL_PATH) + + +@lru_cache(maxsize=1) +def _load_t_model(): + """Load and cache model T.""" + logger.info("Loading model T from %s", T_MODEL_PATH) + return joblib.load(T_MODEL_PATH) + + +@lru_cache(maxsize=None) +def _load_category_orders_cached(path: Path) -> Dict[str, Any]: + """ + Cache category orders per path to avoid disk I/O on each scoring. + """ + logger.info("Loading category orders from %s", path) + return _load_category_orders(path) + + +def _get_expected_features(model: Any, df: pd.DataFrame) -> List[str]: + """ + Get the expected feature names from the model. + + If the model has no 'feature_names' attribute, fall back to df columns. + This is a defensive measure; ideally, feature names should always + be stored with the model. + """ + feature_names = getattr(model, "feature_names", None) + if feature_names is None: + logger.warning( + "Model has no attribute 'feature_names'; using DataFrame columns order." + ) + feature_names = list(df.columns) + return list(feature_names) + + +# --------------------------------------------------------------------------- +# Preprocessing helpers +# --------------------------------------------------------------------------- +MISSING_SENTINELS = [None, "", "null", np.nan, "nan", " "] + + +def _to_string_category(series: pd.Series) -> pd.Series: + """ + Force a categorical series whose categories are strings (not floats), + backed by NumPy object dtype (not pandas StringDtype) for XGBoost + compatibility. + """ + s = series.copy() + s.replace(MISSING_SENTINELS, np.nan, inplace=True) + # Use classic Python strings (object dtype), not pandas' StringDtype, + # so that XGBoost's numpy-based dtype checks work correctly. + s = s.astype(str) + return s.astype("category") + + +def _sanitize_expected_feature_dtypes( + df: pd.DataFrame, + expected_features: List[str], + categorical_feature_names: List[str], +) -> pd.DataFrame: + """ + XGBoost DMatrix does NOT allow object dtype. + + For each expected feature column: + - If dtype is numeric or bool, keep as-is. + - If categorical with float categories, convert to string categories. + - If object: + * try numeric coercion + * if still not usable, cast to string category. + + This mirrors the safety checks needed to satisfy the + XGBoost 3.x pandas backend (`enable_categorical=True`). + """ + df = df.copy() + categorical_set = set(categorical_feature_names) + + for col in expected_features: + if col not in df.columns: + # Ensure column exists so downstream checks don't fail here. + df[col] = np.nan + + dtype = df[col].dtype + + # If this feature is known to be categorical from training-time + # category_orders, assume _prepare_* already produced a proper + # pandas Categorical with the training categories and leave it + # untouched so that category codes match training. + if col in categorical_set: + continue + + # For non-categorical features, XGBoost expects numeric or bool. + if is_bool_dtype(dtype) or is_integer_dtype(dtype) or is_float_dtype(dtype): + continue + + # Anything else (object, string, unexpected categorical) -> numeric coercion. + numeric = pd.to_numeric(df[col], errors="coerce") + df[col] = numeric + + return df + +def _prepare_a(df: pd.DataFrame, category_orders: Dict[str, List[Any]]) -> pd.DataFrame: + """ + Prepare features for model A. + + For each column with category orders: + - If all category labels are numeric-like, coerce both labels and + data to floats and build a numeric categorical. + - Otherwise, treat as string categories. + """ + df = df.copy() + for col, raw_categories in category_orders.items(): + if col not in df.columns: + df[col] = np.nan + + df[col].replace(MISSING_SENTINELS, np.nan, inplace=True) + + # Detect whether category labels are numeric-like and, if so, + # map numeric values onto the canonical string labels used + # during training (e.g. -4 -> "-4.0"). + numeric_like = True + numeric_label_map: Dict[float, str] = {} + for v in raw_categories: + try: + numeric_label_map[float(v)] = str(v) + except (TypeError, ValueError): + numeric_like = False + break + + if numeric_like: + def _map_value(val: Any) -> Any: + if pd.isna(val): + return np.nan + try: + key = float(val) + except (TypeError, ValueError): + return np.nan + return numeric_label_map.get(key, np.nan) + + df[col] = df[col].map(_map_value) + df[col] = pd.Categorical(df[col], categories=raw_categories, ordered=True) + else: + # Pure string categories: coerce to plain strings + df[col] = df[col].astype(str) + df[col] = pd.Categorical(df[col], categories=raw_categories, ordered=True) + + return df + + +def _prepare_with_lower(df: pd.DataFrame, category_orders: Dict[str, List[Any]]) -> pd.DataFrame: + """ + Shared preparation logic for models B and T where + categorical values are lowercased strings. + """ + df = df.copy() + for col, raw_categories in category_orders.items(): + if col not in df.columns: + df[col] = np.nan + + # Normalize missing-like representations + df[col].replace(MISSING_SENTINELS, np.nan, inplace=True) + + # Detect whether category labels are numeric-like and, if so, + # map numeric values onto the canonical string labels used + # during training (e.g. -4 -> "-4.0"). Otherwise, treat + # them as lowercased string categories. + numeric_like = True + numeric_label_map: Dict[float, str] = {} + for v in raw_categories: + try: + numeric_label_map[float(v)] = str(v) + except (TypeError, ValueError): + numeric_like = False + break + + if numeric_like: + def _map_value(val: Any) -> Any: + if pd.isna(val): + return np.nan + try: + key = float(val) + except (TypeError, ValueError): + return np.nan + return numeric_label_map.get(key, np.nan) + + df[col] = df[col].map(_map_value) + df[col] = pd.Categorical(df[col], categories=raw_categories, ordered=True) + else: + # String categories: lower-case string representation + df[col] = df[col].astype(str).str.lower() + df[col] = pd.Categorical(df[col], categories=raw_categories, ordered=True) + + return df + + +def _prepare_b(df: pd.DataFrame, category_orders: Dict[str, List[Any]]) -> pd.DataFrame: + """ + Prepare features for model B (lowercased categorical values). + """ + return _prepare_with_lower(df, category_orders) + + +def _prepare_t(df: pd.DataFrame, category_orders: Dict[str, List[Any]]) -> pd.DataFrame: + """ + Prepare features for model T (lowercased categorical values). + """ + return _prepare_with_lower(df, category_orders) + + +# --------------------------------------------------------------------------- +# Per-model processing functions +# --------------------------------------------------------------------------- + +def processing_a(input_data: pd.DataFrame) -> float: + """ + Run model A on input_data and return the first prediction as float. + """ + df = pd.DataFrame(input_data) + if df.empty: + raise ValueError("Input DataFrame for model A is empty.") + + model = _load_a_model() + category_orders = _load_category_orders_cached(A_CATEGORY_ORDERS_PATH) + df = _prepare_a(df, category_orders) + + expected_features = _get_expected_features(model, df) + df = _sanitize_expected_feature_dtypes(df, expected_features, list(category_orders.keys())) + # Ensure all expected features exist in df + missing_features = set(expected_features) - set(df.columns) + if missing_features: + raise KeyError( + f"Missing expected features for model A: {sorted(missing_features)}" + ) + + dmatrix = xgb.DMatrix(df[expected_features], enable_categorical=True, missing=np.nan) + predictions = model.predict(dmatrix) + + if len(predictions) == 0: + raise RuntimeError("Model A returned no predictions.") + + pd_a = float(predictions[0]) + return pd_a + + +def processing_b(input_data: pd.DataFrame) -> float: + """ + Run model B on input_data and return the first prediction as float. + """ + df = pd.DataFrame(input_data) + if df.empty: + raise ValueError("Input DataFrame for model B is empty.") + + model = _load_b_model() + category_orders = _load_category_orders_cached(B_CATEGORY_ORDERS_PATH) + df = _prepare_b(df, category_orders) + + expected_features = _get_expected_features(model, df) + df = _sanitize_expected_feature_dtypes(df, expected_features, list(category_orders.keys())) + missing_features = set(expected_features) - set(df.columns) + if missing_features: + raise KeyError( + f"Missing expected features for model B: {sorted(missing_features)}" + ) + + dmatrix = xgb.DMatrix(df[expected_features], enable_categorical=True, missing=np.nan) + predictions = model.predict(dmatrix) + + if len(predictions) == 0: + raise RuntimeError("Model B returned no predictions.") + + pd_b = float(predictions[0]) + return pd_b + + +def processing_t(input_data: pd.DataFrame) -> float: + """ + Run model T on input_data and return the first prediction as float. + """ + df = pd.DataFrame(input_data) + if df.empty: + raise ValueError("Input DataFrame for model T is empty.") + + model = _load_t_model() + category_orders = _load_category_orders_cached(T_CATEGORY_ORDERS_PATH) + df = _prepare_t(df, category_orders) + + expected_features = _get_expected_features(model, df) + df = _sanitize_expected_feature_dtypes(df, expected_features, list(category_orders.keys())) + missing_features = set(expected_features) - set(df.columns) + if missing_features: + raise KeyError( + f"Missing expected features for model T: {sorted(missing_features)}" + ) + + dmatrix = xgb.DMatrix(df[expected_features], enable_categorical=True, missing=np.nan) + predictions = model.predict(dmatrix) + + if len(predictions) == 0: + raise RuntimeError("Model T returned no predictions.") + + pd_t = float(predictions[0]) + return pd_t + + +def processing_all( + df_a: pd.DataFrame, + df_b: pd.DataFrame, + df_t: pd.DataFrame, +) -> Tuple[float, float, float]: + """ + Convenience function to run all three models and return their predictions. + """ + return ( + processing_a(df_a), + processing_b(df_b), + processing_t(df_t), + ) + + +# --------------------------------------------------------------------------- +# Main entrypoint for batch-style input +# --------------------------------------------------------------------------- + +def __main__(results: List[Dict[str, Any]]) -> Tuple[float, float, float]: + """ + Main entrypoint for processing a list of results dicts. + + Expected shape of each element in `results`: + { + "model_a_features": { ... feature_name: value ... }, + "model_b_features": { ... feature_name: value ... }, + "model_t_features": { ... feature_name: value ... }, + } + """ + logger.info("Data received in processing block: %s", results) + + df = pd.DataFrame(results) + if df.empty: + raise ValueError("Input results list is empty.") + + if not {"model_a_features", "model_b_features", "model_t_features"}.issubset(df.columns): + missing = { + "model_a_features", + "model_b_features", + "model_t_features", + } - set(df.columns) + raise KeyError( + f"Missing expected keys in results: {sorted(missing)}" + ) + + # Each cell of these columns is expected to be a dict-like object + df_a = pd.DataFrame(list(df["model_a_features"])) + df_b = pd.DataFrame(list(df["model_b_features"])) + df_t = pd.DataFrame(list(df["model_t_features"])) + + pd_a, pd_b, pd_t = processing_all(df_a, df_b, df_t) + return { + "pd_a": pd_a, + "pd_b": pd_b, + "pd_t": pd_t, + } diff --git a/category_orders_train_A.json b/category_orders_train_A.json new file mode 100644 index 0000000..86b40b2 --- /dev/null +++ b/category_orders_train_A.json @@ -0,0 +1,15 @@ +{ + "G300S": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ] +} \ No newline at end of file diff --git a/category_orders_train_B.json b/category_orders_train_B.json new file mode 100644 index 0000000..5cb99bf --- /dev/null +++ b/category_orders_train_B.json @@ -0,0 +1,2728 @@ +{ + "G301S": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "RVLR14": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i t", + "i i", + "i ii", + "i ir", + "i it", + "i rr", + "i rt", + "i i", + "i ii", + "i iii", + "i irr", + "i itr", + "i tt", + "i ttt", + "i i", + "i iii", + "i iiii", + "i irrr", + "i it", + "i itii", + "i ittt", + "i rrrr", + "i trrr", + "i i", + "i iiiii", + "i iiiir", + "i iiiit", + "i iiitt", + "i iit", + "i iitrt", + "i irrrr", + "i irrtt", + "i irtrr", + "i irtrt", + "i itiii", + "i itrt", + "i itrti", + "i itt", + "i ittt", + "i itttt", + "i rrrrr", + "i rrrrt", + "i rrtt", + "i titt", + "i tt tt", + "i ttitt", + "i ttrrr", + "i ttttt", + "i i", + "i i rrrt", + "i iii", + "i iiiiii", + "i iiiiit", + "i iiirrr", + "i iiitt", + "i iiittt", + "i iirrrr", + "i iittt", + "i irrrrr", + "i irrrtr", + "i irrttt", + "i itit", + "i itrrtt", + "i itt", + "i ittt", + "i ittttr", + "i ittttt", + "i rrrtrr", + "i rrrtrt", + "i rrtrtt", + "i t", + "i ttrrtt", + "i ttrtti", + "i ttttrr", + "i ttttti", + "i tttttt", + "ii", + "ii trtr", + "ii iiiii", + "ii rrrrr", + "ii t", + "ii ttttt", + "iii", + "iii i ii", + "iii iiii", + "iii tttt", + "iiii", + "iiii ii", + "iiii ii", + "iiii iii", + "iiii iir", + "iiii iit", + "iiii rrt", + "iiii rtt", + "iiii t", + "iiiii", + "iiiii ii", + "iiiiii", + "iiiiii i", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirti", + "iiiiirtr", + "iiiiit", + "iiiiitii", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrtt", + "iiiirt", + "iiiirtii", + "iiiirtrr", + "iiiirtt", + "iiiit", + "iiiit ii", + "iiiitiii", + "iiiititi", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrtt", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrtrr", + "iiirtrt", + "iiirtrtr", + "iiirttii", + "iiirttrt", + "iiit", + "iiit t", + "iiiti", + "iiiti tr", + "iiitii", + "iiitiiii", + "iiitiiti", + "iiititit", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrtrr", + "iiitrttt", + "iiitt", + "iiittiii", + "iiittiit", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiitttii", + "iiitttit", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrt", + "iirrrrtr", + "iirrrrtt", + "iirrrt r", + "iirrtrt", + "iirrtrtr", + "iirrtrtt", + "iirrttii", + "iirrtttt", + "iirt rrr", + "iirtiiii", + "iirtrrrt", + "iirtrrtr", + "iirtrtrt", + "iirtrtti", + "iirtt", + "iirttrrt", + "iirttttt", + "iit", + "iiti", + "iiti iii", + "iitii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiiti", + "iitiiitt", + "iitiitii", + "iitiitt", + "iitit", + "iititi", + "iitititi", + "iititti", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrtrt", + "iitrrtti", + "iitrrttr", + "iitrt", + "iitrtiii", + "iitrtrtr", + "iitt", + "iitti", + "iittiiir", + "iittiiit", + "iittiitt", + "iittirrr", + "iittirti", + "iittittt", + "iittrttt", + "iittt", + "iittt ii", + "iittti", + "iitttiii", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrti", + "iitttrtt", + "iitttt", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrtrr", + "irrrrtt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrtrrt", + "irrrtrtt", + "irrrttrr", + "irrrttt", + "irrrtttt", + "irrt", + "irrt t", + "irrt tt", + "irrtitir", + "irrtitit", + "irrtrrti", + "irrtrtrt", + "irrtrttr", + "irrtrttt", + "irrttti", + "irrtttrr", + "irrtttrt", + "irrtttt", + "irrttttr", + "irrttttt", + "irt", + "irti", + "irtiiiii", + "irtirtrt", + "irtrrrrr", + "irtrrrtt", + "irtrrt", + "irtrt", + "irtrtrtr", + "irtrtrtt", + "irtrtttt", + "irtt", + "irtt tt", + "irtt ttr", + "irttii", + "irttiirt", + "irttirrt", + "irttirtr", + "irttrrrr", + "irttrrrt", + "irttrttt", + "irtttrtt", + "irtttti", + "irttttii", + "irttttrr", + "irttttrt", + "irttttt", + "irtttttt", + "it", + "it trt", + "it irrrr", + "it irtti", + "it rrrrt", + "it ttrt", + "it ttrtr", + "it tttrt", + "it tttt", + "it ttttt", + "iti", + "iti i", + "itii", + "itiiii", + "itiiiiii", + "itiiiiit", + "itiiiit", + "itiiit", + "itiiitii", + "itiiittt", + "itiirrrr", + "itiit", + "itiitit", + "itiititt", + "itiitt", + "itiittrr", + "itiittrt", + "itiittt", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirtirt", + "itirtt", + "itirtttt", + "itit", + "ititiii", + "ititiiir", + "ititiiti", + "ititirrr", + "itititi", + "itititrt", + "ititt", + "ititti", + "itittiii", + "itittiti", + "itittitt", + "itittrti", + "itittt", + "ititttit", + "ititttt", + "ititttti", + "itittttr", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrtrr", + "itrrrtt", + "itrrrttt", + "itrrtiir", + "itrrtrrt", + "itrrtrtr", + "itrrtt", + "itrrttit", + "itrrtttr", + "itrrtttt", + "itrt", + "itrtitrr", + "itrtrrrr", + "itrtrtrr", + "itrtrtrt", + "itrtrttr", + "itrtrttt", + "itrttrrt", + "itrtttrt", + "itrtttt", + "itrttttt", + "itt", + "itt t", + "itt trrr", + "itti", + "itti tt", + "ittii", + "ittiiiii", + "ittiiiti", + "ittiiitt", + "ittiitii", + "ittiitit", + "ittiitrt", + "ittiitt", + "ittiitti", + "ittiittt", + "ittirrrt", + "ittirrtt", + "ittit", + "ittitiii", + "ittitiit", + "ittitrti", + "ittitt", + "ittittrr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrttt", + "ittrt", + "ittrt tt", + "ittrtirt", + "ittrtrrr", + "ittrtrrt", + "ittrtrtt", + "ittrtt", + "ittrttir", + "ittrttrr", + "ittrttrt", + "ittrtttt", + "ittt", + "ittt r", + "ittt ttt", + "ittti", + "itttiiii", + "itttiiti", + "itttiitt", + "itttit", + "itttitit", + "itttitti", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtt", + "itttrt", + "itttrtir", + "itttrtrr", + "itttrtrt", + "itttrttr", + "itttrttt", + "itttt", + "itttt tt", + "itttti", + "ittttiii", + "ittttiit", + "ittttirt", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt t", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "rirrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt i", + "rrrrt r", + "rrrrt t", + "rrrrt i", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt ii", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt ti", + "rrrt tr", + "rrrt tt", + "rrrt i", + "rrrt ii", + "rrrt iii", + "rrrt iit", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t t", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt tti", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti ir", + "rrrtii", + "rrrtii t", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtitii", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt i", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt t", + "rrt tr", + "rrt tt", + "rrt rrr", + "rrt rtt", + "rrt itrr", + "rrt rrrr", + "rrt rrrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t rr", + "rrt t ti", + "rrt trrr", + "rrt trrt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt ttrr", + "rrt ttrt", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti t", + "rrti rrr", + "rrtii", + "rrtii i", + "rrtiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrtr", + "rrtirrtt", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitiit", + "rrtititt", + "rrtitrrr", + "rrtitrrt", + "rrtitrti", + "rrtitt", + "rrtittrr", + "rrtittrt", + "rrtitttr", + "rrtitttt", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt i", + "rrtrt rr", + "rrtrt rt", + "rrtrt t", + "rrtrt ti", + "rrtrt tr", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtirr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt rr", + "rrtt t", + "rrtt ti", + "rrtt tr", + "rrtt tt", + "rrtt iit", + "rrtt itt", + "rrtt rrr", + "rrtt rrt", + "rrtt rt", + "rrtt rti", + "rrtt rtr", + "rrtt rtt", + "rrtt trr", + "rrtt trt", + "rrtt tt", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiit", + "rrttiirr", + "rrttiit", + "rrttiiti", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttiti", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrti", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt rr", + "rrttt rt", + "rrttt t", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttit", + "rrtttiti", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt i", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt t", + "rt rr", + "rt rrr", + "rt trt", + "rt ttr", + "rt ttt", + "rt ii", + "rt irrt", + "rt rrrr", + "rt t rr", + "rt trrr", + "rt trtt", + "rt tt", + "rt ttrr", + "rt tttt", + "rt i", + "rt iiiii", + "rt iiirr", + "rt irrrr", + "rt itrtr", + "rt ittt", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrti", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrti", + "rt rrtrr", + "rt rrtrt", + "rt rrtti", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rti", + "rt rtirr", + "rt rtrrr", + "rt rtrrt", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rttii", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t rr", + "rt t rt", + "rt t tt", + "rt t rrr", + "rt t ttr", + "rt t ttt", + "rt tirtt", + "rt trrrr", + "rt trrrt", + "rt trrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trtrr", + "rt tt", + "rt tt t", + "rt ttrrt", + "rt ttrtr", + "rt ttrtt", + "rt ttt", + "rt tttrr", + "rt tttrt", + "rt tttt", + "rt ttttr", + "rt ttttt", + "rti", + "rti irrr", + "rtii", + "rtii rr", + "rtiii", + "rtiii ii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiitr", + "rtiiirrr", + "rtiiitii", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrtt", + "rtiirt", + "rtiirti", + "rtiirtir", + "rtiirtrr", + "rtiirtt", + "rtiit", + "rtiit t", + "rtiitiit", + "rtiitrrr", + "rtiitrti", + "rtiittrr", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtt", + "rtirrt", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirt rt", + "rtirtirr", + "rtirtrrr", + "rtirtrtt", + "rtirtt", + "rtirttir", + "rtirttrr", + "rtirtttt", + "rtit", + "rtit it", + "rtitirrr", + "rtitirti", + "rtititrr", + "rtititti", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrti", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtii", + "rtitrtrt", + "rtitrtt", + "rtitrttt", + "rtitt", + "rtittiit", + "rtittitr", + "rtittitt", + "rtittrrt", + "rtittrtr", + "rtittrtt", + "rtitttt", + "rtittttt", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt ii", + "rtrrt it", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtirr", + "rtrrtirt", + "rtrrtitr", + "rtrrtitt", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt r", + "rtrt t", + "rtrt i", + "rtrt rr", + "rtrt t", + "rtrt tr", + "rtrt irr", + "rtrt itt", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rti", + "rtrt rtr", + "rtrt rtt", + "rtrt t", + "rtrt trr", + "rtrt trt", + "rtrt tt", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiitr", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtitrr", + "rtrtitrt", + "rtrtittt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt r", + "rtrtt t", + "rtrtt rr", + "rtrtt rt", + "rtrtt t", + "rtrtt tr", + "rtrtt tt", + "rtrtti", + "rtrttiii", + "rtrttiir", + "rtrttiit", + "rtrttirr", + "rtrttit", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt r", + "rtrttti", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt rr", + "rtt t", + "rtt tt", + "rtt rt", + "rtt trr", + "rtt tt", + "rtt i", + "rtt iiii", + "rtt rrrr", + "rtt rrrt", + "rtt rrti", + "rtt rrtr", + "rtt rtrr", + "rtt rtrt", + "rtt rttr", + "rtt rttt", + "rtt t", + "rtt t r", + "rtt t rr", + "rtt trrr", + "rtt trrt", + "rtt trt", + "rtt trtr", + "rtt ttrr", + "rtt ttt", + "rtt ttti", + "rtt tttr", + "rtt tttt", + "rtti", + "rtti rrr", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiitt", + "rttiirrr", + "rttiitrr", + "rttiitrt", + "rttiittr", + "rttirrrr", + "rttirrrt", + "rttirrti", + "rttirrtr", + "rttirt", + "rttirtii", + "rttirtrr", + "rttirttr", + "rttirttt", + "rttit", + "rttit tt", + "rttiti", + "rttitiir", + "rttitirr", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrtr", + "rttitt", + "rttitti", + "rttittit", + "rttittrr", + "rttittrt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrtii", + "rttrrtir", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt r", + "rttrt ir", + "rttrt rr", + "rttrt rt", + "rttrt t", + "rttrt tt", + "rttrti", + "rttrtit", + "rttrtitr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtti", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt rr", + "rttt i", + "rttt rrr", + "rttt rrt", + "rttt rt", + "rttt rtt", + "rttt trr", + "rttt trt", + "rttt tt", + "rttt tti", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttiiii", + "rtttiit", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttitit", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrt t", + "rtttrtii", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rtttti t", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t ii", + "t rr", + "t rt", + "t t", + "t tr", + "t i", + "t rrr", + "t rrt", + "t rtt", + "t t", + "t trr", + "t trt", + "t tt", + "t ttt", + "t i", + "t itrt", + "t rrrr", + "t rrrt", + "t rrtr", + "t rtii", + "t rtrt", + "t rttt", + "t t", + "t t t", + "t t rr", + "t trrt", + "t trtr", + "t trtt", + "t ttrt", + "t ttt", + "t tttt", + "t i rtr", + "t iiiii", + "t iiirt", + "t iirrt", + "t ittti", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrti", + "t rrrtr", + "t rrrtt", + "t rrt r", + "t rrtrr", + "t rrttt", + "t rt", + "t rtrrr", + "t rtrrt", + "t rtrt", + "t rtrtr", + "t rtt t", + "t rttrr", + "t rttrt", + "t rtttt", + "t t", + "t t rr", + "t t tt", + "t t rrr", + "t trrrr", + "t trrrt", + "t trrtr", + "t trt", + "t trtii", + "t trtrr", + "t trtrt", + "t trtti", + "t trttt", + "t tt", + "t tt rt", + "t tt t", + "t ttiit", + "t ttrrr", + "t ttrtt", + "t ttt", + "t tttrr", + "t tttrt", + "t tttt", + "t ttttt", + "t i", + "t i rti", + "t iiiiii", + "t iittt", + "t irrrrr", + "t irrttt", + "t it", + "t it r", + "t itiiii", + "t itittt", + "t itrrrr", + "t itrrtt", + "t ittii", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrti", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrtti", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrt rt", + "t rrti", + "t rrtiii", + "t rrtirr", + "t rrtitt", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrtti", + "t rrttii", + "t rrttrr", + "t rrttrt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt rrr", + "t rt rrt", + "t rti", + "t rtiiii", + "t rtrrrr", + "t rtrrrt", + "t rtrrtr", + "t rtrrtt", + "t rtrt", + "t rtrti", + "t rtrtrr", + "t rtrtrt", + "t rtrtt", + "t rtrttr", + "t rtt", + "t rtt tt", + "t rttitt", + "t rttrrr", + "t rttrrt", + "t rttrtr", + "t rttrtt", + "t rttt", + "t rttti", + "t rtttit", + "t rtttrr", + "t rtttrt", + "t rtttt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t t r", + "t t t", + "t t rr", + "t t rt", + "t t tr", + "t t rrr", + "t t rtt", + "t t t", + "t t trr", + "t t trt", + "t t rrrr", + "t t rrrt", + "t t rtrr", + "t t rtrt", + "t t rttt", + "t t t", + "t t t rr", + "t t t rt", + "t t tt", + "t t ttii", + "t ti", + "t tiiii", + "t tiiiii", + "t tiirti", + "t titttt", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrtrr", + "t trrtrt", + "t trrtt", + "t trrttr", + "t trrttt", + "t trt", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrtr", + "t trtt", + "t trttrr", + "t trttrt", + "t trttt", + "t trttti", + "t trtttr", + "t trtttt", + "t tt", + "t tt tr", + "t tt tt", + "t tt i t", + "t tt rrr", + "t tt rt", + "t tt rtr", + "t tt t", + "t tt trt", + "t tt tt", + "t tt ttt", + "t tti", + "t ttiiii", + "t ttitrt", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrtr", + "t ttrrtt", + "t ttrt", + "t ttrtrr", + "t ttrtrt", + "t ttrtt", + "t ttrtti", + "t ttrttr", + "t ttrttt", + "t ttt", + "t ttt t", + "t ttti", + "t tttiii", + "t tttiit", + "t tttrrr", + "t tttrrt", + "t tttrt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttti", + "t ttttii", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t tttttr", + "t tttttt", + "ti", + "ti i", + "ti rrrt", + "ti t", + "ti ti", + "ti trt", + "ti tt", + "ti ttttt", + "tii", + "tii ti", + "tiii", + "tiii iii", + "tiiii", + "tiiiii", + "tiiiii i", + "tiiiiii", + "tiiiiiii", + "tiiiiiit", + "tiiiiirr", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirtr", + "tiiiirtt", + "tiiiit", + "tiiiitii", + "tiiiitrr", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtt", + "tiiirtrr", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiittii", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrtr", + "tiirrtir", + "tiirrttt", + "tiirt rr", + "tiirtitr", + "tiirttii", + "tiit", + "tiitiiii", + "tiitiiit", + "tiitiitt", + "tiitirrt", + "tiitit", + "tiititii", + "tiititir", + "tiititrr", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrti", + "tiitrtrr", + "tiitrtt", + "tiitrtti", + "tiitrttt", + "tiitt", + "tiitti", + "tiittii", + "tiittiii", + "tiittit", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittt", + "tiitttii", + "tiitttit", + "tiitttt", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtrr", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrtrrr", + "tirrtrrt", + "tirrtrtr", + "tirrttrr", + "tirrttrt", + "tirrtttr", + "tirrtttt", + "tirt", + "tirtiitt", + "tirtirrt", + "tirtiti", + "tirtitrr", + "tirtrrrr", + "tirtrrrt", + "tirtrrt", + "tirtrrtt", + "tirtrtrr", + "tirtrttr", + "tirtrttt", + "tirtt", + "tirttitt", + "tirttrrr", + "tirttrrt", + "tirttrtt", + "tirtttrt", + "tirtttti", + "tirttttt", + "tit", + "tit rrt", + "tit tiir", + "tit trtt", + "tit ttrr", + "titi", + "titii", + "titiii", + "titiiiii", + "titiiiti", + "titiiitt", + "titiit", + "titiitii", + "titiitit", + "titiitt", + "titiittt", + "titit", + "titit rr", + "tititi", + "tititiii", + "tititiit", + "tititit", + "titititi", + "titititt", + "tititrtt", + "tititt", + "titittii", + "titittit", + "titittrr", + "titittt", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrti", + "titrrrtt", + "titrrt", + "titrrti", + "titrrtrr", + "titrrtrt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrt tr", + "titrti", + "titrtirt", + "titrtrrr", + "titrtrrt", + "titrtrtt", + "titrtt", + "titrttit", + "titrttrt", + "titrttt", + "titrttti", + "titrtttr", + "titrtttt", + "titt", + "titt tt", + "titti", + "tittii", + "tittiiii", + "tittiiit", + "tittiiti", + "tittiitr", + "tittiitt", + "tittitrt", + "tittitti", + "tittittr", + "tittittt", + "tittrrrr", + "tittrrtr", + "tittrtrr", + "tittrtt", + "tittt", + "tittt rr", + "tittt ti", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttit", + "titttiti", + "titttitt", + "titttrrt", + "titttrtt", + "titttt", + "titttt t", + "tittttii", + "tittttit", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt t", + "trrrt rr", + "trrrt rt", + "trrrt t", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtitt", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrttii", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt i", + "trrt ii", + "trrt rr", + "trrt t", + "trrt tr", + "trrt rrr", + "trrt rrt", + "trrt rt", + "trrt rtr", + "trrt rtt", + "trrt t", + "trrt ti", + "trrt trr", + "trrt trt", + "trrt ttr", + "trrt ttt", + "trrti", + "trrtiiit", + "trrtiirr", + "trrtiitt", + "trrtirrr", + "trrtiti", + "trrtitrr", + "trrtittt", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt t", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt rr", + "trrtt rt", + "trrtt t", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrttiii", + "trrttiit", + "trrttit", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrttt t", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt rr", + "trt rrr", + "trt trr", + "trt tt", + "trt irrr", + "trt itti", + "trt ittt", + "trt rrrr", + "trt rrrt", + "trt rrtr", + "trt rrtt", + "trt rtrr", + "trt rtrt", + "trt rttt", + "trt t", + "trt t t", + "trt t rr", + "trt t t", + "trt t tr", + "trt trrr", + "trt trrt", + "trt trt", + "trt trtr", + "trt tt", + "trt ttrt", + "trt ttt", + "trt tttr", + "trti", + "trti ir", + "trti rr", + "trtii", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiiiit", + "trtiiirr", + "trtiiitr", + "trtiiitt", + "trtiirrr", + "trtiirrt", + "trtiit", + "trtirrrr", + "trtirrrt", + "trtirrtt", + "trtirt", + "trtirtti", + "trtirttt", + "trtit", + "trtit ir", + "trtitiit", + "trtitrrr", + "trtitrrt", + "trtitt", + "trtittit", + "trtittrt", + "trtitttr", + "trtitttt", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrti", + "trtrrtit", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt rr", + "trtrt t", + "trtrt tr", + "trtrt tt", + "trtrti", + "trtrtiti", + "trtrtitr", + "trtrtitt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtt t", + "trtrtti", + "trtrttir", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt r", + "trtt i", + "trtt rrr", + "trtt rrt", + "trtt rtr", + "trtt rtt", + "trtt t", + "trtt trr", + "trtt trt", + "trtt tt", + "trtt ttr", + "trtt ttt", + "trtti", + "trttiii", + "trttiiii", + "trttiirt", + "trttiitr", + "trttirrt", + "trttirti", + "trttirtr", + "trttitii", + "trttitit", + "trttitrr", + "trttitrt", + "trttittr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt t", + "trttrtit", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrttr", + "trttrttt", + "trttt", + "trttt it", + "trttt rt", + "trttt t", + "trttt tr", + "trttt tt", + "trttti", + "trtttiii", + "trtttiit", + "trtttirr", + "trtttirt", + "trtttit", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt t", + "trtttti", + "trttttii", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt r", + "tt t", + "tt i", + "tt ir", + "tt rr", + "tt t", + "tt tt", + "tt rrr", + "tt t", + "tt t t", + "tt trt", + "tt ttt", + "tt irrr", + "tt rrrr", + "tt rrtr", + "tt rttt", + "tt t r", + "tt t rr", + "tt t tr", + "tt trt", + "tt tt", + "tt ttt", + "tt tttt", + "tt i", + "tt i trt", + "tt ii", + "tt iitii", + "tt irrrr", + "tt it", + "tt rrrrr", + "tt rrrrt", + "tt rrrt", + "tt rrrtr", + "tt rrrtt", + "tt rrt r", + "tt rrtrr", + "tt rrttt", + "tt rt", + "tt rt rr", + "tt rtrrr", + "tt rtrrt", + "tt rtrt", + "tt rtrtr", + "tt rtrtt", + "tt rtt", + "tt rtt r", + "tt rttrt", + "tt rtttr", + "tt rtttt", + "tt t", + "tt t t", + "tt t rr", + "tt t t", + "tt t rrr", + "tt t rt", + "tt t trt", + "tt titt", + "tt trrrr", + "tt trrrt", + "tt trrt", + "tt trrtr", + "tt trrtt", + "tt trt", + "tt trtrr", + "tt trtrt", + "tt trttr", + "tt trttt", + "tt tt", + "tt tt r", + "tt tt rt", + "tt tti", + "tt ttiit", + "tt ttrrr", + "tt ttrrt", + "tt ttrt", + "tt ttrtt", + "tt ttt", + "tt ttt t", + "tt tttii", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttt", + "tti", + "tti tt", + "tti ttt", + "tti t rr", + "tti tiii", + "tti ttit", + "ttii", + "ttii rr", + "ttii iii", + "ttiii", + "ttiiii", + "ttiiii t", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirtt", + "ttiiiti", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtt", + "ttiirt", + "ttiirtit", + "ttiirtrt", + "ttiirtt", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiitiii", + "ttiitiit", + "ttiitirr", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtr", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrtrr", + "ttirrtt", + "ttirt", + "ttirtiti", + "ttirtrrr", + "ttirtrrt", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttii", + "ttirttit", + "ttirttrt", + "ttirttt", + "ttirtttt", + "ttit", + "ttit ii", + "ttit iti", + "ttit trr", + "ttit tt", + "ttiti", + "ttitiiii", + "ttitiiit", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirtt", + "ttitit", + "ttititi", + "ttititit", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrtr", + "ttitrtrr", + "ttitrtrt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt tr", + "ttitti", + "ttittii", + "ttittiii", + "ttittiit", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt t", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrtii", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt r", + "ttrrt t", + "ttrrt rr", + "ttrrt rt", + "ttrrt t", + "ttrrt tt", + "ttrrti", + "ttrrtitr", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrttir", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt t", + "ttrt rr", + "ttrt rt", + "ttrt tr", + "ttrt tt", + "ttrt rrr", + "ttrt rrt", + "ttrt rtt", + "ttrt t", + "ttrt t t", + "ttrt ti", + "ttrt trr", + "ttrt trt", + "ttrt ttt", + "ttrti", + "ttrtiii", + "ttrtirtt", + "ttrtit", + "ttrtitrr", + "ttrtitrt", + "ttrtitt", + "ttrtitti", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrt t", + "ttrtrti", + "ttrtrtii", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt i", + "ttrtt rr", + "ttrtt tr", + "ttrtt tt", + "ttrtti", + "ttrttiii", + "ttrttiit", + "ttrttirr", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrtttii", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt r", + "ttt t", + "ttt rr", + "ttt rt", + "ttt tr", + "ttt iii", + "ttt rrr", + "ttt rrt", + "ttt rtr", + "ttt rtt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt trr", + "ttt trt", + "ttt tt", + "ttt ttr", + "ttt ttt", + "ttt i", + "ttt ii", + "ttt iiii", + "ttt iiit", + "ttt rrrr", + "ttt rrrt", + "ttt rrt", + "ttt rrtr", + "ttt rrtt", + "ttt rt r", + "ttt rtrr", + "ttt rtrt", + "ttt rttt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt t t", + "ttt t tr", + "ttt ti", + "ttt tii", + "ttt trrr", + "ttt trrt", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt tt r", + "ttt tt t", + "ttt tti", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt ttti", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti i", + "ttti rrr", + "ttti ttt", + "tttii", + "tttii tt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiit r", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitt", + "tttiitti", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrtr", + "tttirrtt", + "tttirtir", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit rt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirr", + "tttitit", + "tttititi", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrirrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrt t", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt t", + "tttrt rr", + "tttrt rt", + "tttrt t", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrtiit", + "tttrtirr", + "tttrtirt", + "tttrtiti", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt t", + "tttrtti", + "tttrttii", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt t", + "tttt ii", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt i", + "tttt ii", + "tttt iii", + "tttt iit", + "tttt irr", + "tttt rrr", + "tttt rrt", + "tttt rt", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti tr", + "ttttii", + "ttttii i", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirtr", + "ttttit", + "ttttit t", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtii", + "ttttrtir", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti i", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ] +} \ No newline at end of file diff --git a/category_orders_train_T.json b/category_orders_train_T.json new file mode 100644 index 0000000..8022320 --- /dev/null +++ b/category_orders_train_T.json @@ -0,0 +1,47386 @@ +{ + "eads55_rvlr61": [ + "-1.0", + "-6.0", + "0.0", + "1.0" + ], + "eads55_rvlr62": [ + "-1.0", + "-6.0", + "0.0", + "1.0" + ], + "eads55_rvlr63": [ + "-1.0", + "-6.0", + "0.0", + "1.0" + ], + "eads55_rvlr64": [ + "-1.0", + "-6.0", + "0.0", + "1.0" + ], + "eads55_rvlr65": [ + "-1.0", + "-6.0", + "0.0", + "1.0" + ], + "eads55_rvlr66": [ + "-1.0", + "-6.0", + "0.0", + "1.0" + ], + "eads56_rvlr78": [ + "-1", + "-6", + "mixbhvr", + "noactbc", + "prrevlr", + "prtrans" + ], + "eads56_rvlr79": [ + "-1", + "-6", + "mixbhvr", + "noactbc", + "prrevlr", + "prtrans" + ], + "eads56_rvlr80": [ + "-1", + "-6", + "mixbhvr", + "noactbc", + "prrevlr", + "prtrans" + ], + "eads56_rvlr81": [ + "-1", + "-6", + "mixbhvr", + "noactbc", + "prrevlr", + "prtrans" + ], + "G300S": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "G301S": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_g302s": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_g303s": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_g304s": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g305s": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g306s": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g307s": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g308s": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g309s": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g310s": [ + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g311s": [ + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "8.0", + "9.0" + ], + "eads142_g312s": [ + "-1.0", + "-2.0", + "-4.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_g313s": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_g314s": [ + "-1.0", + "-2.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_g315s": [ + "-1.0", + "-4.0", + "0.0", + "1.0", + "10.0", + "2.0", + "3.0", + "4.0", + "5.0", + "9.0" + ], + "eads142_st60s": [ + "0.0", + "1.0" + ], + "RVLR14": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i r", + "i t", + "i i", + "i ii", + "i ir", + "i it", + "i rt", + "i t", + "i tr", + "i tt", + "i i", + "i ii", + "i iii", + "i irr", + "i it", + "i itr", + "i rrr", + "i t", + "i tt", + "i tti", + "i ttr", + "i ttt", + "i i", + "i i ii", + "i ii", + "i iii", + "i iiii", + "i iirr", + "i irrr", + "i irtt", + "i it", + "i itii", + "i itrr", + "i itt", + "i itti", + "i ittt", + "i rrrr", + "i rtrr", + "i rttr", + "i t", + "i trrr", + "i tt", + "i ttrr", + "i tttt", + "i i", + "i i i", + "i ii ii", + "i iiii", + "i iiiii", + "i iiiir", + "i iiiit", + "i iiitt", + "i iirrr", + "i iirrt", + "i iit", + "i iitrr", + "i iitrt", + "i iittr", + "i iittt", + "i irrrr", + "i irrtr", + "i irrtt", + "i irtrr", + "i irttr", + "i it", + "i itiii", + "i ititt", + "i itrrr", + "i itrrt", + "i itrt", + "i itrti", + "i itrtr", + "i itrtt", + "i itt", + "i itti", + "i ittrt", + "i ittt", + "i itttr", + "i itttt", + "i rrrrr", + "i rrrrt", + "i rrtt", + "i rrttt", + "i rtttr", + "i t", + "i titt", + "i trrrr", + "i tt tt", + "i ttrrr", + "i ttrti", + "i tttrr", + "i tttt", + "i ttttt", + "i i", + "i i iiii", + "i i rrrt", + "i i tttt", + "i ii", + "i ii tt", + "i iii", + "i iiiii", + "i iiiiii", + "i iiiiir", + "i iiiiit", + "i iiiit", + "i iiiiti", + "i iiirrr", + "i iiit", + "i iiitt", + "i iiittt", + "i iirrrr", + "i iirrrt", + "i iittrr", + "i iittt", + "i irrrrr", + "i irrrrt", + "i irrtrt", + "i irrttr", + "i irrttt", + "i irt t", + "i irtrtr", + "i irtrtt", + "i irttti", + "i irtttt", + "i it", + "i it t t", + "i it ttt", + "i itiiii", + "i itit", + "i itrrrt", + "i itrrtt", + "i itt", + "i itti", + "i ittiii", + "i ittrrr", + "i ittrtt", + "i ittt", + "i itttrr", + "i itttrt", + "i ittttr", + "i ittttt", + "i rrrrrr", + "i rrrrtr", + "i rrrtrr", + "i rrrtrt", + "i rrrttt", + "i rrt", + "i rrtrtt", + "i rt ttt", + "i rtrt", + "i rttttt", + "i t", + "i t trti", + "i trrrrr", + "i trrtrt", + "i trrttt", + "i trtrrt", + "i trttrr", + "i trtttt", + "i tt", + "i tt rrr", + "i tti", + "i ttiiii", + "i ttrrtt", + "i ttrtti", + "i ttt", + "i ttt tr", + "i ttttrr", + "i ttttt", + "i ttttti", + "i tttttr", + "i tttttt", + "ii", + "ii i", + "ii ttt", + "ii trtr", + "ii ttii", + "ii tttt", + "ii i", + "ii ii i", + "ii ii ii", + "ii iiii", + "ii iiiii", + "ii iiiir", + "ii iiirt", + "ii iitti", + "ii rrrrr", + "ii rrrti", + "ii rt tt", + "ii t", + "ii ttttt", + "iii", + "iii t", + "iii iti", + "iii i ii", + "iii ii", + "iii iiii", + "iii iiit", + "iii t", + "iii tii", + "iii tt i", + "iii ttii", + "iii tttt", + "iiii", + "iiii ii", + "iiii ii", + "iiii iii", + "iiii iir", + "iiii iit", + "iiii iti", + "iiii rrr", + "iiii rrt", + "iiii t", + "iiii ttr", + "iiii ttt", + "iiiii", + "iiiii i", + "iiiii ii", + "iiiii rr", + "iiiiii", + "iiiiii i", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirtii", + "iiiirtrr", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiit ii", + "iiiit rr", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitit", + "iiiititi", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitt t", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrtt", + "iiirrt", + "iiirrt r", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrttt", + "iiirt", + "iiirtiii", + "iiirtirr", + "iiirtrrr", + "iiirtrt", + "iiirtrtr", + "iiirtrtt", + "iiirttit", + "iiirttrt", + "iiirttt", + "iiirtttt", + "iiit", + "iiit rr", + "iiit rtt", + "iiit ttr", + "iiiti", + "iiiti tr", + "iiitii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitirtt", + "iiitit", + "iiititii", + "iiititit", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrtii", + "iiitrtrr", + "iiitrtrt", + "iiitrtt", + "iiitrttt", + "iiitt", + "iiitt ii", + "iiitti", + "iiitti i", + "iiittiii", + "iiittiit", + "iiittirr", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrt r", + "iirrrtrr", + "iirrrttt", + "iirrtiii", + "iirrtiir", + "iirrtiti", + "iirrtitr", + "iirrtrrr", + "iirrtrtr", + "iirrtrtt", + "iirrtt", + "iirrttii", + "iirrttit", + "iirrttrr", + "iirrttt", + "iirrtttt", + "iirt", + "iirt rrr", + "iirtiiii", + "iirtiiir", + "iirtitrr", + "iirtittt", + "iirtrrrr", + "iirtrrrt", + "iirtrrtr", + "iirtrtrr", + "iirtrtrt", + "iirtrtti", + "iirtt", + "iirttrrr", + "iirttrrt", + "iirttt", + "iirtttrt", + "iirtttt", + "iirttttt", + "iit", + "iit itti", + "iit ttrt", + "iit tttt", + "iiti", + "iiti iii", + "iitii", + "iitiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiit", + "iitiiiti", + "iitiiitt", + "iitiitii", + "iitiitrt", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrtr", + "iitirti", + "iitit", + "iititi", + "iititiit", + "iitititi", + "iitititt", + "iititt", + "iititti", + "iitittit", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrtr", + "iitrrrtt", + "iitrrt", + "iitrrtrr", + "iitrrtrt", + "iitrrtti", + "iitrrttr", + "iitrt", + "iitrtiii", + "iitrtiit", + "iitrtrt", + "iitrtrtr", + "iitrtt", + "iitrttrt", + "iitrtttt", + "iitt", + "iitt trr", + "iitti", + "iitti tt", + "iittii", + "iittiii", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiitt", + "iittirrr", + "iittirti", + "iittirtr", + "iittit", + "iittitt", + "iittitti", + "iittittr", + "iittittt", + "iittrrrr", + "iittrrt", + "iittrrtr", + "iittrtrr", + "iittrttr", + "iittrttt", + "iittt", + "iittt t", + "iittt ii", + "iittt tt", + "iittti", + "iitttiii", + "iitttiit", + "iitttit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrti", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttir", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrt r", + "irrrrti", + "irrrrtit", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrtiii", + "irrrtiir", + "irrrtit", + "irrrtitr", + "irrrtrrr", + "irrrtrrt", + "irrrtrti", + "irrrtrtr", + "irrrtrtt", + "irrrttrr", + "irrrttrt", + "irrrttt", + "irrrtttr", + "irrrtttt", + "irrt", + "irrt t", + "irrt tt", + "irrtiiii", + "irrtiitt", + "irrtirrr", + "irrtitii", + "irrtitir", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrti", + "irrtrtrr", + "irrtrtrt", + "irrtrtt", + "irrtrttr", + "irrtrttt", + "irrtt t", + "irrtt tr", + "irrttit", + "irrttrrr", + "irrttrrt", + "irrttrtt", + "irrttti", + "irrtttrr", + "irrtttrt", + "irrtttt", + "irrtttti", + "irrttttr", + "irrttttt", + "irt", + "irti", + "irtiiiii", + "irtiiitt", + "irtiitit", + "irtirt", + "irtirtrt", + "irtirttt", + "irtittrt", + "irtrrrrr", + "irtrrrrt", + "irtrrrtt", + "irtrrt", + "irtrrt r", + "irtrrtrr", + "irtrrttr", + "irtrrttt", + "irtrt", + "irtrtrrr", + "irtrtrrt", + "irtrtrtr", + "irtrtrtt", + "irtrtttr", + "irtrtttt", + "irtt", + "irtt r", + "irtt tt", + "irtt rtt", + "irtt ttr", + "irtt ttt", + "irttii", + "irttiiii", + "irttirrt", + "irttirtr", + "irttirtt", + "irttrrrr", + "irttrrrt", + "irttrrti", + "irttrrtr", + "irttrrtt", + "irttrt", + "irttrt t", + "irttrtrr", + "irttrtt", + "irttrttr", + "irttrttt", + "irtttiii", + "irtttrrt", + "irtttrtr", + "irtttrtt", + "irtttt", + "irttttii", + "irttttit", + "irttttrr", + "irttttrt", + "irttttt", + "irttttti", + "irtttttr", + "irtttttt", + "it", + "it t", + "it ttt", + "it trt", + "it iiiii", + "it iitii", + "it irrrr", + "it irtti", + "it rrrrr", + "it rrtrt", + "it t", + "it ttiii", + "it ttrt", + "it ttrtr", + "it tttrt", + "it tttt", + "it ttttt", + "iti", + "iti tt", + "iti i", + "itii", + "itiii", + "itiii tt", + "itiiii", + "itiiiiii", + "itiiiiit", + "itiiiit", + "itiiiiti", + "itiiiitt", + "itiiit", + "itiiitii", + "itiiitit", + "itiiittt", + "itiirrrr", + "itiirrtr", + "itiirtt", + "itiit", + "itiitiii", + "itiitiit", + "itiitit", + "itiititi", + "itiititt", + "itiitt", + "itiittii", + "itiittrr", + "itiittt", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirtirt", + "itirtt", + "itirttrt", + "itirtttt", + "itit", + "ititi", + "ititiii", + "ititiiii", + "ititiiir", + "ititiiit", + "ititiiti", + "ititirrr", + "ititit", + "itititi", + "itititii", + "itititit", + "itititrt", + "itititti", + "ititittt", + "ititrttr", + "ititt", + "ititti", + "itittiii", + "itittirt", + "itittiti", + "itittitt", + "itittrtt", + "itittt", + "ititttii", + "ititttit", + "ititttt", + "ititttti", + "itittttr", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrtrr", + "itrrrtrt", + "itrrrtt", + "itrrrttr", + "itrrrttt", + "itrrt", + "itrrtiir", + "itrrtrrr", + "itrrtrrt", + "itrrtrtr", + "itrrtrtt", + "itrrttit", + "itrrttrr", + "itrrtttr", + "itrrtttt", + "itrt", + "itrt rrr", + "itrt rrt", + "itrtitrr", + "itrtrrrr", + "itrtrrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrtrr", + "itrtrtrt", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrttirt", + "itrttitr", + "itrttitt", + "itrttrrr", + "itrttrrt", + "itrttrt", + "itrttrti", + "itrttrtr", + "itrttrtt", + "itrttt", + "itrtttrt", + "itrttttr", + "itrttttt", + "itt", + "itt itit", + "itt rrtt", + "itt rttt", + "itt t", + "itt trrr", + "itt trtt", + "itt ttit", + "itt ttt", + "itti", + "itti rtr", + "ittii", + "ittiii", + "ittiiiii", + "ittiiiit", + "ittiiirr", + "ittiiit", + "ittiiiti", + "ittiiitt", + "ittiitii", + "ittiitit", + "ittiitrt", + "ittiitt", + "ittiitti", + "ittiittt", + "ittirrrt", + "ittirrtt", + "ittirtt", + "ittirttt", + "ittit", + "ittitiii", + "ittitiit", + "ittititi", + "ittititt", + "ittitrti", + "ittitt", + "ittitt t", + "ittittii", + "ittittt", + "ittittti", + "ittitttr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrtrr", + "ittrrtrt", + "ittrrttt", + "ittrt", + "ittrt tt", + "ittrtirt", + "ittrtitt", + "ittrtrrr", + "ittrtrrt", + "ittrtrt", + "ittrtrtr", + "ittrtrtt", + "ittrtt", + "ittrttir", + "ittrttrr", + "ittrttrt", + "ittrttti", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt r", + "ittt tt", + "ittt rrr", + "ittt rrt", + "ittt tti", + "ittt ttr", + "ittt ttt", + "ittti", + "itttii", + "itttiiii", + "itttiiit", + "itttiit", + "itttiiti", + "itttiitt", + "itttit", + "itttitii", + "itttitit", + "itttitrr", + "itttitt", + "itttitti", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrtii", + "itttrtir", + "itttrtrr", + "itttrtrt", + "itttrtt", + "itttrttr", + "itttrttt", + "itttt", + "itttt tt", + "itttti", + "ittttiii", + "ittttiir", + "ittttiit", + "ittttirr", + "ittttirt", + "ittttit", + "ittttiti", + "ittttitr", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt t", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "rirrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt i", + "rrrrt ii", + "rrrrt ir", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt ti", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt i", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt i", + "rrrt ii", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt ti", + "rrrt tr", + "rrrt tt", + "rrrt i", + "rrrt ii", + "rrrt iii", + "rrrt iir", + "rrrt iit", + "rrrt irr", + "rrrt irt", + "rrrt iti", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t r", + "rrrt t t", + "rrrt ti", + "rrrt tii", + "rrrt tir", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt tti", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti ir", + "rrrti t", + "rrrti tt", + "rrrtii", + "rrrtii i", + "rrrtii t", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtit t", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt i", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt t", + "rrrtt i", + "rrrtt ii", + "rrrtt ir", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt i", + "rrt ii", + "rrt rr", + "rrt rt", + "rrt t", + "rrt tr", + "rrt tt", + "rrt iii", + "rrt irr", + "rrt rrr", + "rrt rrt", + "rrt rt", + "rrt rtr", + "rrt t r", + "rrt trt", + "rrt ttr", + "rrt ttt", + "rrt i", + "rrt iiii", + "rrt irrr", + "rrt irrt", + "rrt irtt", + "rrt itii", + "rrt itrr", + "rrt ittt", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rt r", + "rrt rtir", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rtti", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t t", + "rrt t rr", + "rrt t rt", + "rrt t ti", + "rrt t tt", + "rrt ti", + "rrt tirr", + "rrt titr", + "rrt titt", + "rrt trrr", + "rrt trrt", + "rrt trt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt tti", + "rrt ttrr", + "rrt ttrt", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti t", + "rrti iir", + "rrti rrr", + "rrti rtr", + "rrti trt", + "rrtii", + "rrtii i", + "rrtii ii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiitii", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirt i", + "rrtirt t", + "rrtirtii", + "rrtirtir", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtit t", + "rrtit it", + "rrtiti", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtitit", + "rrtititr", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtitttr", + "rrtitttt", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt i", + "rrtrt ii", + "rrtrt rr", + "rrtrt rt", + "rrtrt t", + "rrtrt ti", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt i", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt t", + "rrtt ii", + "rrtt rr", + "rrtt rt", + "rrtt t", + "rrtt ti", + "rrtt tr", + "rrtt tt", + "rrtt i", + "rrtt iir", + "rrtt iit", + "rrtt itt", + "rrtt rrr", + "rrtt rrt", + "rrtt rt", + "rrtt rti", + "rrtt rtr", + "rrtt rtt", + "rrtt t", + "rrtt t r", + "rrtt trr", + "rrtt trt", + "rrtt tt", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrtti i", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit r", + "rrttiti", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt i", + "rrttt ii", + "rrttt rr", + "rrttt rt", + "rrttt t", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt i", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt t", + "rt ii", + "rt ir", + "rt rr", + "rt rt", + "rt t", + "rt tr", + "rt tt", + "rt irr", + "rt rrr", + "rt rrt", + "rt t", + "rt t r", + "rt trr", + "rt trt", + "rt tt", + "rt ttr", + "rt ttt", + "rt i", + "rt i ir", + "rt irrr", + "rt irrt", + "rt rrrr", + "rt rrrt", + "rt rrt", + "rt rrtr", + "rt rttr", + "rt t rr", + "rt t tt", + "rt trrr", + "rt trrt", + "rt trtt", + "rt tt", + "rt tt t", + "rt ttrr", + "rt tttt", + "rt i", + "rt i t", + "rt i iii", + "rt iiiii", + "rt iiiit", + "rt iiirr", + "rt iirrr", + "rt iirtt", + "rt iitrr", + "rt irrrr", + "rt irrti", + "rt itit", + "rt itrrr", + "rt itrtr", + "rt ittii", + "rt ittt", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrti", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrt r", + "rt rrti", + "rt rrtit", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrtti", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rt r", + "rt rt rr", + "rt rt rt", + "rt rti", + "rt rtirr", + "rt rtrrr", + "rt rtrrt", + "rt rtrt", + "rt rtrti", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rtt r", + "rt rtti", + "rt rttii", + "rt rttrr", + "rt rttrt", + "rt rttt", + "rt rttti", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t rr", + "rt t rt", + "rt t tt", + "rt t rrr", + "rt t rrt", + "rt t rtt", + "rt t trr", + "rt t ttr", + "rt ti", + "rt tirtt", + "rt titrt", + "rt trrrr", + "rt trrrt", + "rt trrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trtrr", + "rt trtrt", + "rt trtt", + "rt trttr", + "rt trttt", + "rt tt", + "rt tt t", + "rt tt t", + "rt tti", + "rt ttrrr", + "rt ttrrt", + "rt ttrt", + "rt ttrtr", + "rt ttrtt", + "rt ttt", + "rt tttit", + "rt tttrr", + "rt tttrt", + "rt tttt", + "rt tttti", + "rt ttttr", + "rt ttttt", + "rti", + "rti t", + "rti irrr", + "rti rrrt", + "rti t", + "rti ttrr", + "rtii", + "rtii rr", + "rtii rrr", + "rtiii", + "rtiii tt", + "rtiiii", + "rtiiii t", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirt", + "rtiiirtt", + "rtiiit", + "rtiiitii", + "rtiiitir", + "rtiiitit", + "rtiiitrr", + "rtiiitt", + "rtiiitti", + "rtiiittr", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirrtt", + "rtiirt", + "rtiirti", + "rtiirtir", + "rtiirtit", + "rtiirtrr", + "rtiirtt", + "rtiit", + "rtiit rt", + "rtiit t", + "rtiitiit", + "rtiitirr", + "rtiititt", + "rtiitrrr", + "rtiitrti", + "rtiitrtt", + "rtiitt", + "rtiittii", + "rtiittrr", + "rtiittrt", + "rtiittti", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrttr", + "rtirt", + "rtirt tt", + "rtirtirr", + "rtirtiti", + "rtirtrrr", + "rtirtrrt", + "rtirtrtt", + "rtirtt", + "rtirtti", + "rtirttii", + "rtirttit", + "rtirttrr", + "rtirttti", + "rtirtttr", + "rtirtttt", + "rtit", + "rtit rr", + "rtit it", + "rtit rtt", + "rtiti", + "rtitiiit", + "rtitiirr", + "rtitiit", + "rtitiitt", + "rtitirrr", + "rtitirti", + "rtitit", + "rtititii", + "rtititir", + "rtititrr", + "rtititt", + "rtititti", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrti", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtit", + "rtitrtrt", + "rtitrtt", + "rtitrttt", + "rtitt", + "rtittiii", + "rtittiit", + "rtittirr", + "rtittiti", + "rtittitt", + "rtittrrr", + "rtittrrt", + "rtittrtr", + "rtittrtt", + "rtittt", + "rtitttii", + "rtitttit", + "rtitttrr", + "rtitttrt", + "rtitttt", + "rtitttti", + "rtittttr", + "rtittttt", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt t", + "rtrrt ii", + "rtrrt ir", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtitr", + "rtrrtitt", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt r", + "rtrt t", + "rtrt i", + "rtrt it", + "rtrt rr", + "rtrt rt", + "rtrt t", + "rtrt tr", + "rtrt tt", + "rtrt irr", + "rtrt iti", + "rtrt itt", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rti", + "rtrt rtr", + "rtrt rtt", + "rtrt t", + "rtrt tii", + "rtrt trr", + "rtrt trt", + "rtrt tt", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiit", + "rtrtiiti", + "rtrtiitr", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtitii", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtitti", + "rtrtittr", + "rtrtittt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt r", + "rtrtt t", + "rtrtt ir", + "rtrtt rr", + "rtrtt rt", + "rtrtt t", + "rtrtt tr", + "rtrtt tt", + "rtrtti", + "rtrtti t", + "rtrttii", + "rtrttiii", + "rtrttiir", + "rtrttiit", + "rtrttirr", + "rtrttirt", + "rtrttit", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt r", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt rr", + "rtt t", + "rtt tr", + "rtt tt", + "rtt iii", + "rtt irr", + "rtt rrr", + "rtt rrt", + "rtt rt", + "rtt trr", + "rtt trt", + "rtt tt", + "rtt i", + "rtt iiii", + "rtt itir", + "rtt rrrr", + "rtt rrrt", + "rtt rrt", + "rtt rrti", + "rtt rrtr", + "rtt rrtt", + "rtt rt", + "rtt rtrr", + "rtt rtrt", + "rtt rttr", + "rtt rttt", + "rtt t", + "rtt t r", + "rtt t rr", + "rtt t tr", + "rtt t tt", + "rtt titt", + "rtt trrr", + "rtt trrt", + "rtt trt", + "rtt trtr", + "rtt tt", + "rtt tt t", + "rtt ttrr", + "rtt ttrt", + "rtt ttt", + "rtt tttr", + "rtt tttt", + "rtti", + "rtti rr", + "rtti tt", + "rtti i", + "rtti iii", + "rtti rrr", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiit", + "rttiiirr", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirtr", + "rttiit", + "rttiitii", + "rttiitit", + "rttiitrr", + "rttiitrt", + "rttiittr", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrt", + "rttirrti", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtii", + "rttirtit", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirtti", + "rttirttr", + "rttirttt", + "rttit", + "rttit tt", + "rttiti", + "rttitiii", + "rttitiir", + "rttitirr", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrt", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttitti", + "rttittii", + "rttittit", + "rttittrr", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrt t", + "rttrrtir", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt r", + "rttrt t", + "rttrt ir", + "rttrt rr", + "rttrt rt", + "rttrt t", + "rttrt ti", + "rttrt tr", + "rttrt tt", + "rttrti", + "rttrtiir", + "rttrtiit", + "rttrtirt", + "rttrtitr", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt t", + "rttrtti", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt t", + "rttt ii", + "rttt rr", + "rttt t", + "rttt i", + "rttt iti", + "rttt itt", + "rttt rrr", + "rttt rrt", + "rttt rt", + "rttt rti", + "rttt rtr", + "rttt rtt", + "rttt t", + "rttt trr", + "rttt trt", + "rttt tt", + "rttt tti", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttii", + "rtttiiii", + "rtttiiir", + "rtttiiit", + "rtttiit", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirti", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrt t", + "rtttrti", + "rtttrtii", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt i", + "rtttt r", + "rtttt t", + "rtttt i", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rtttti t", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt i", + "rttttt r", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t i", + "t ii", + "t rr", + "t rt", + "t t", + "t ti", + "t tr", + "t tt", + "t i", + "t itt", + "t rrr", + "t rrt", + "t rtr", + "t rtt", + "t t", + "t t r", + "t t t", + "t trr", + "t trt", + "t tt", + "t ttt", + "t i", + "t iiii", + "t ittt", + "t rrrr", + "t rrrt", + "t rrtr", + "t rrtt", + "t rt", + "t rtii", + "t rtrr", + "t rtrt", + "t rttt", + "t t", + "t t r", + "t t t", + "t t rr", + "t t t", + "t t tt", + "t trrr", + "t trrt", + "t trt", + "t trtr", + "t trtt", + "t ttii", + "t ttt", + "t ttti", + "t tttt", + "t i", + "t i rtr", + "t iii", + "t iiiii", + "t iiirt", + "t iiitt", + "t iirrt", + "t iittt", + "t irrrr", + "t it", + "t it ii", + "t itrtr", + "t ittti", + "t itttt", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrti", + "t rrrtr", + "t rrrtt", + "t rrt", + "t rrti", + "t rrtrr", + "t rrtrt", + "t rrtt", + "t rrttt", + "t rt", + "t rt rr", + "t rt rt", + "t rti", + "t rtiii", + "t rtrrr", + "t rtrrt", + "t rtrt", + "t rtrtr", + "t rtt", + "t rtt r", + "t rtt t", + "t rtti", + "t rttrt", + "t rtttt", + "t t", + "t t rr", + "t t rt", + "t t t", + "t t tt", + "t t rrr", + "t t trt", + "t t ttr", + "t ti", + "t tittt", + "t trrrr", + "t trrrt", + "t trrtr", + "t trrtt", + "t trt", + "t trtrr", + "t trtrt", + "t trtt", + "t trtti", + "t trttr", + "t trttt", + "t tt", + "t tt t", + "t tt t", + "t tt tt", + "t ttiit", + "t ttirt", + "t ttrrr", + "t ttrrt", + "t ttrti", + "t ttrtt", + "t ttt", + "t tttir", + "t tttrr", + "t tttrt", + "t tttt", + "t tttti", + "t ttttr", + "t ttttt", + "t i", + "t i rti", + "t i rrtr", + "t i tttt", + "t ii", + "t iiii", + "t iiiiii", + "t iiit", + "t iiitii", + "t iirrrr", + "t iitrrr", + "t iitrrt", + "t iitt", + "t iittii", + "t iittt", + "t irrrrr", + "t irrrrt", + "t irrttt", + "t irt", + "t irti", + "t irtrrt", + "t it", + "t it r", + "t itiiit", + "t itiitt", + "t itrrrr", + "t itrrti", + "t itrrtt", + "t itt", + "t ittii", + "t ittttt", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrt r", + "t rrrt t", + "t rrrti", + "t rrrtii", + "t rrrtir", + "t rrrtit", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrtti", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt r", + "t rrt t", + "t rrt rr", + "t rrt rt", + "t rrti", + "t rrtiii", + "t rrtirr", + "t rrtirt", + "t rrtitt", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrti", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrttii", + "t rrttrr", + "t rrttrt", + "t rrttt", + "t rrttti", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt t", + "t rt rr", + "t rt rrr", + "t rt rrt", + "t rt rtt", + "t rt t t", + "t rt trr", + "t rt trt", + "t rti", + "t rtiiii", + "t rtiirr", + "t rtittt", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrrti", + "t rtrrtr", + "t rtrrtt", + "t rtrt", + "t rtrtii", + "t rtrtit", + "t rtrtrr", + "t rtrtrt", + "t rtrtt", + "t rtrttr", + "t rtrttt", + "t rtt", + "t rtt tr", + "t rtt tt", + "t rtti", + "t rttitt", + "t rttrrr", + "t rttrrt", + "t rttrt", + "t rttrtr", + "t rttrtt", + "t rttt", + "t rttti", + "t rtttii", + "t rtttit", + "t rtttrr", + "t rtttrt", + "t rtttt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t t r", + "t t t", + "t t rr", + "t t rt", + "t t t", + "t t tr", + "t t tt", + "t t rrr", + "t t rt", + "t t rtt", + "t t t", + "t t t t", + "t t trr", + "t t trt", + "t t tt", + "t t tti", + "t t ttt", + "t t rrrr", + "t t rrrt", + "t t rrtr", + "t t rt r", + "t t rtrr", + "t t rtrt", + "t t rttt", + "t t t", + "t t t r", + "t t t rr", + "t t t rt", + "t t trtr", + "t t tt", + "t t ttii", + "t t ttrt", + "t t ttt", + "t t tttt", + "t ti", + "t tii", + "t tiiii", + "t tiiiii", + "t tiiiti", + "t tiirti", + "t tiit", + "t tiitir", + "t tiitti", + "t tirrrr", + "t titt", + "t tittti", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrt r", + "t trrtrr", + "t trrtrt", + "t trrtt", + "t trrtti", + "t trrttr", + "t trrttt", + "t trt", + "t trt rr", + "t trt tr", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrti", + "t trtrtr", + "t trtrtt", + "t trtt", + "t trtti", + "t trttrr", + "t trttrt", + "t trttt", + "t trttti", + "t trtttr", + "t trtttt", + "t tt", + "t tt t", + "t tt rr", + "t tt t", + "t tt tr", + "t tt tt", + "t tt i t", + "t tt rrr", + "t tt rrt", + "t tt rt", + "t tt rtr", + "t tt t", + "t tt trr", + "t tt trt", + "t tt tt", + "t tt ttt", + "t tti", + "t ttiiii", + "t ttiiit", + "t ttirtt", + "t ttitit", + "t ttitrt", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrt", + "t ttrrtr", + "t ttrrtt", + "t ttrt", + "t ttrtrr", + "t ttrtrt", + "t ttrtt", + "t ttrtti", + "t ttrttr", + "t ttrttt", + "t ttt", + "t ttt t", + "t ttt rt", + "t ttt tt", + "t ttti", + "t tttii", + "t tttiii", + "t tttiit", + "t tttitt", + "t tttrrr", + "t tttrrt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttti", + "t ttttii", + "t ttttit", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti t", + "ti trr", + "ti i", + "ti i t", + "ti iiirr", + "ti iiitr", + "ti irrrt", + "ti irt", + "ti rrrrr", + "ti rtrrr", + "ti ti", + "ti trrtt", + "ti trt", + "ti tt", + "ti ttttt", + "tii", + "tii tt", + "tii tt", + "tii iiii", + "tii ti", + "tiii", + "tiii ii", + "tiii iii", + "tiii rrr", + "tiii tt", + "tiiii", + "tiiii ii", + "tiiiii", + "tiiiii i", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirt", + "tiiiirtt", + "tiiiit", + "tiiiit r", + "tiiiitii", + "tiiiitir", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtr", + "tiiirrtt", + "tiiirt", + "tiiirtrr", + "tiiirttt", + "tiiit", + "tiiit it", + "tiiiti", + "tiiiti t", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitit", + "tiiititi", + "tiiititr", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrt r", + "tiirrtir", + "tiirrttt", + "tiirt", + "tiirt rr", + "tiirtiir", + "tiirtirt", + "tiirtitr", + "tiirtrrr", + "tiirttit", + "tiirttrr", + "tiirtttt", + "tiit", + "tiit ii", + "tiit i", + "tiit trt", + "tiiti", + "tiitii", + "tiitiii", + "tiitiiii", + "tiitiiir", + "tiitiiit", + "tiitiitr", + "tiitiitt", + "tiitirrr", + "tiitirrt", + "tiitit", + "tiititii", + "tiititir", + "tiititit", + "tiititrr", + "tiititrt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrt", + "tiitrti", + "tiitrtii", + "tiitrtrr", + "tiitrtrt", + "tiitrtt", + "tiitrtti", + "tiitrttr", + "tiitrttt", + "tiitt", + "tiitt ti", + "tiitt tt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittirt", + "tiittit", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrt", + "tiittrtr", + "tiittrtt", + "tiittt", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrt r", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrtti", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrt r", + "tirrtirr", + "tirrtirt", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrt", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrtt r", + "tirrttii", + "tirrttrr", + "tirrttrt", + "tirrttti", + "tirrtttr", + "tirrtttt", + "tirt", + "tirt t", + "tirti", + "tirtiiit", + "tirtiirr", + "tirtirrt", + "tirtit", + "tirtiti", + "tirtitrr", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrrt", + "tirtrrtr", + "tirtrrtt", + "tirtrt", + "tirtrtrr", + "tirtrtrt", + "tirtrtt", + "tirtrttr", + "tirtrttt", + "tirtt", + "tirtti", + "tirttiit", + "tirttrrr", + "tirttrrt", + "tirttrti", + "tirttrtr", + "tirttrtt", + "tirttt", + "tirtttrr", + "tirtttrt", + "tirtttt", + "tirtttti", + "tirttttr", + "tirttttt", + "tit", + "tit ti", + "tit trt", + "tit rrtt", + "tit rt r", + "tit t", + "tit ttrr", + "tit ttti", + "tit tttt", + "titi", + "titi it", + "titii", + "titiii", + "titiiii", + "titiiiii", + "titiiiit", + "titiiirt", + "titiiit", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirtt", + "titiit", + "titiitii", + "titiitit", + "titiitrr", + "titiitt", + "titiitti", + "titiittt", + "titirrrr", + "titirtii", + "titirtrt", + "titirttr", + "titit", + "titit i", + "titit rr", + "tititi", + "tititii", + "tititiii", + "tititiit", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititrrt", + "tititrtt", + "tititt", + "tititti", + "titittii", + "titittit", + "titittrr", + "titittrt", + "titittt", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrti", + "titrrtit", + "titrrtrr", + "titrrtrt", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrt tr", + "titrt tt", + "titrti", + "titrtii", + "titrtiii", + "titrtirt", + "titrtitt", + "titrtrrr", + "titrtrrt", + "titrtrt", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrtti", + "titrttii", + "titrttit", + "titrttrr", + "titrttrt", + "titrttt", + "titrttti", + "titrtttr", + "titrtttt", + "titt", + "titt tt", + "titt ttr", + "titt ttt", + "titti", + "tittii", + "tittiii", + "tittiiii", + "tittiiit", + "tittiirr", + "tittiit", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirrr", + "tittirtt", + "tittit", + "tittitii", + "tittitit", + "tittitrt", + "tittitt", + "tittitti", + "tittittr", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrt", + "tittrrti", + "tittrrtr", + "tittrrtt", + "tittrtrr", + "tittrtrt", + "tittrtt", + "tittrtti", + "tittrttr", + "tittrttt", + "tittt", + "tittt rr", + "tittt ti", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttirr", + "titttirt", + "titttit", + "titttiti", + "titttitr", + "titttitt", + "titttrrr", + "titttrrt", + "titttrt", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttir", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt t", + "trrrt rr", + "trrrt rt", + "trrrt t", + "trrrt ti", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtiti", + "trrrtitt", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt i", + "trrt ii", + "trrt ir", + "trrt rr", + "trrt rt", + "trrt t", + "trrt ti", + "trrt tr", + "trrt irt", + "trrt rrr", + "trrt rrt", + "trrt rt", + "trrt rtr", + "trrt rtt", + "trrt t", + "trrt t t", + "trrt ti", + "trrt tir", + "trrt tit", + "trrt trr", + "trrt trt", + "trrt tt", + "trrt tti", + "trrt ttr", + "trrt ttt", + "trrti", + "trrtii", + "trrtii t", + "trrtiii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirr", + "trrtiit", + "trrtiitr", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirt", + "trrtirtt", + "trrtit", + "trrtiti", + "trrtitii", + "trrtitrr", + "trrtitrt", + "trrtitt", + "trrtittr", + "trrtittt", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrt t", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt rr", + "trrtt rt", + "trrtt t", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrttiii", + "trrttiit", + "trrttirr", + "trrttit", + "trrttiti", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrttt t", + "trrttti", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt t", + "trt rr", + "trt rrr", + "trt rt", + "trt rtt", + "trt trr", + "trt tt", + "trt tti", + "trt irrr", + "trt itrr", + "trt itti", + "trt ittt", + "trt rrrr", + "trt rrrt", + "trt rrt", + "trt rrtr", + "trt rrtt", + "trt rtrr", + "trt rtrt", + "trt rttt", + "trt t", + "trt t t", + "trt t rr", + "trt t rt", + "trt t t", + "trt trrr", + "trt trrt", + "trt trt", + "trt trtr", + "trt trtt", + "trt tt", + "trt ttii", + "trt ttrr", + "trt ttrt", + "trt ttt", + "trt tttr", + "trt tttt", + "trti", + "trti rr", + "trti rtt", + "trtii", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiiiit", + "trtiiirr", + "trtiiitt", + "trtiirrr", + "trtiirrt", + "trtiirti", + "trtiirtt", + "trtiit", + "trtiitrt", + "trtiittt", + "trtirrrr", + "trtirrrt", + "trtirrtr", + "trtirrtt", + "trtirt", + "trtirtir", + "trtirtit", + "trtirtrr", + "trtirtrt", + "trtirtt", + "trtirtti", + "trtirttr", + "trtirttt", + "trtit", + "trtit ir", + "trtit t", + "trtitiit", + "trtititi", + "trtitrrr", + "trtitrrt", + "trtitrtr", + "trtitrtt", + "trtitt", + "trtittii", + "trtittit", + "trtittrt", + "trtitttr", + "trtitttt", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrti", + "trtrrtii", + "trtrrtir", + "trtrrtit", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt t", + "trtrt rr", + "trtrt rt", + "trtrt t", + "trtrt tr", + "trtrt tt", + "trtrti", + "trtrtiii", + "trtrtiir", + "trtrtiit", + "trtrtirr", + "trtrtirt", + "trtrtit", + "trtrtiti", + "trtrtitr", + "trtrtitt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtt t", + "trtrtti", + "trtrttii", + "trtrttir", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt r", + "trtt t", + "trtt rr", + "trtt tr", + "trtt i", + "trtt rrr", + "trtt rrt", + "trtt rtr", + "trtt rtt", + "trtt t", + "trtt t r", + "trtt trr", + "trtt trt", + "trtt ttr", + "trtt ttt", + "trtti", + "trtti t", + "trttii", + "trttiii", + "trttiiii", + "trttiiir", + "trttiirt", + "trttiiti", + "trttiitr", + "trttirrr", + "trttirrt", + "trttirti", + "trttirtr", + "trttirtt", + "trttit", + "trttit r", + "trttiti", + "trttitii", + "trttitit", + "trttitrr", + "trttitrt", + "trttitt", + "trttittr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt r", + "trttrt t", + "trttrtii", + "trttrtir", + "trttrtit", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt it", + "trttt rr", + "trttt rt", + "trttt t", + "trttt tr", + "trttt tt", + "trttti", + "trtttii", + "trtttiii", + "trtttirr", + "trtttirt", + "trtttit", + "trtttiti", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt r", + "tt t", + "tt i", + "tt ii", + "tt ir", + "tt it", + "tt rr", + "tt rt", + "tt t", + "tt tr", + "tt tt", + "tt iii", + "tt irr", + "tt it", + "tt itt", + "tt rrr", + "tt rrt", + "tt rtr", + "tt rtt", + "tt t", + "tt t t", + "tt trt", + "tt ttt", + "tt iiii", + "tt irrr", + "tt rrrr", + "tt rrrt", + "tt rrt", + "tt rrtr", + "tt rrtt", + "tt rtrr", + "tt rtrt", + "tt rtt", + "tt rttt", + "tt t", + "tt t r", + "tt t t", + "tt t rr", + "tt t tr", + "tt t tt", + "tt tiii", + "tt trrr", + "tt trrt", + "tt trt", + "tt trti", + "tt trtr", + "tt tt", + "tt tti", + "tt ttrt", + "tt ttt", + "tt tttr", + "tt tttt", + "tt i", + "tt i trt", + "tt ii", + "tt iitii", + "tt iitt", + "tt irrrr", + "tt irttr", + "tt it", + "tt itrrr", + "tt ittrt", + "tt itttt", + "tt rrrrr", + "tt rrrrt", + "tt rrrt", + "tt rrrtr", + "tt rrrtt", + "tt rrt", + "tt rrt r", + "tt rrtrr", + "tt rrtrt", + "tt rrttr", + "tt rrttt", + "tt rt", + "tt rt t", + "tt rt rr", + "tt rtiir", + "tt rtirt", + "tt rtitt", + "tt rtrrr", + "tt rtrrt", + "tt rtrt", + "tt rtrtr", + "tt rtrtt", + "tt rtt", + "tt rtt r", + "tt rttii", + "tt rttrr", + "tt rttrt", + "tt rtttr", + "tt rtttt", + "tt t", + "tt t r", + "tt t t", + "tt t rr", + "tt t t", + "tt t tt", + "tt t rrr", + "tt t rrt", + "tt t rt", + "tt t t", + "tt t t t", + "tt t trt", + "tt t tt", + "tt t ttt", + "tt tiitt", + "tt titi", + "tt titt", + "tt tittr", + "tt trrrr", + "tt trrrt", + "tt trrt", + "tt trrtr", + "tt trrtt", + "tt trt", + "tt trtrr", + "tt trtrt", + "tt trtt", + "tt trtti", + "tt trttr", + "tt trttt", + "tt tt", + "tt tt r", + "tt tt t", + "tt tt rt", + "tt tt t", + "tt tt tt", + "tt tti", + "tt ttiii", + "tt ttiit", + "tt ttirr", + "tt ttitt", + "tt ttrrr", + "tt ttrrt", + "tt ttrt", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt ttt t", + "tt ttti", + "tt tttii", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti i", + "tti tt", + "tti tti", + "tti ttt", + "tti t rr", + "tti tiii", + "tti trtr", + "tti trtt", + "tti ttit", + "tti tttt", + "ttii", + "ttii rr", + "ttii iii", + "ttiii", + "ttiii rr", + "ttiiii", + "ttiiii t", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtr", + "ttiiirtt", + "ttiiit", + "ttiiiti", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtr", + "ttiirrtt", + "ttiirt", + "ttiirti", + "ttiirtit", + "ttiirtrt", + "ttiirtt", + "ttiirtti", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiit", + "ttiitirr", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrt", + "ttiitrti", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitt r", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrtit", + "ttirrtrr", + "ttirrtrt", + "ttirrtt", + "ttirrttt", + "ttirt", + "ttirti", + "ttirtit", + "ttirtiti", + "ttirtitt", + "ttirtrrr", + "ttirtrrt", + "ttirtrt", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttii", + "ttirttir", + "ttirttit", + "ttirttrt", + "ttirttt", + "ttirttti", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit ii", + "ttit iti", + "ttit rrr", + "ttit trr", + "ttit tt", + "ttit ttt", + "ttiti", + "ttitii", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiit", + "ttitiiti", + "ttitiitr", + "ttitiitt", + "ttitirrr", + "ttitirtr", + "ttitirtt", + "ttitit", + "ttititi", + "ttititii", + "ttititit", + "ttititrt", + "ttititt", + "ttititti", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrt", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtrr", + "ttitrtrt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt i", + "ttitt tr", + "ttitt tt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiir", + "ttittiit", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitr", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt t", + "ttittti", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt r", + "ttrrt t", + "ttrrt ir", + "ttrrt rr", + "ttrrt rt", + "ttrrt t", + "ttrrt tr", + "ttrrt tt", + "ttrrti", + "ttrrti r", + "ttrrtiit", + "ttrrtit", + "ttrrtiti", + "ttrrtitr", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrtt t", + "ttrrtti", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt r", + "ttrt t", + "ttrt rr", + "ttrt rt", + "ttrt tr", + "ttrt tt", + "ttrt i", + "ttrt rrr", + "ttrt rrt", + "ttrt rtr", + "ttrt rtt", + "ttrt t", + "ttrt t t", + "ttrt ti", + "ttrt trr", + "ttrt trt", + "ttrt tt", + "ttrt ttt", + "ttrti", + "ttrti ii", + "ttrtii", + "ttrtii r", + "ttrtiii", + "ttrtiiii", + "ttrtiirr", + "ttrtiirt", + "ttrtiit", + "ttrtiitt", + "ttrtirrr", + "ttrtirt", + "ttrtirtr", + "ttrtirtt", + "ttrtit", + "ttrtitir", + "ttrtitrr", + "ttrtitrt", + "ttrtitt", + "ttrtitti", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrt t", + "ttrtrti", + "ttrtrtii", + "ttrtrtir", + "ttrtrtit", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt r", + "ttrtt i", + "ttrtt rr", + "ttrtt t", + "ttrtt tr", + "ttrtt tt", + "ttrtti", + "ttrttii", + "ttrttiii", + "ttrttiir", + "ttrttirr", + "ttrttirt", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrttti", + "ttrtttii", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt i", + "ttt r", + "ttt t", + "ttt ii", + "ttt rr", + "ttt rt", + "ttt t", + "ttt tr", + "ttt tt", + "ttt i", + "ttt iit", + "ttt irt", + "ttt rrr", + "ttt rrt", + "ttt rt", + "ttt rtr", + "ttt rtt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt trr", + "ttt trt", + "ttt tt", + "ttt ttr", + "ttt ttt", + "ttt i", + "ttt i ir", + "ttt ii", + "ttt iii", + "ttt iiii", + "ttt iiit", + "ttt itt", + "ttt rrrr", + "ttt rrrt", + "ttt rrtr", + "ttt rrtt", + "ttt rt", + "ttt rt r", + "ttt rtrr", + "ttt rtrt", + "ttt rtt", + "ttt rttr", + "ttt rttt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt t rr", + "ttt t t", + "ttt t tr", + "ttt t tt", + "ttt ti", + "ttt tii", + "ttt titt", + "ttt trrr", + "ttt trrt", + "ttt trti", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt tt r", + "ttt tt t", + "ttt tti", + "ttt ttit", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt ttti", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti rt", + "ttti tt", + "ttti i", + "ttti rrr", + "ttti rrt", + "ttti rtt", + "ttti trr", + "ttti ttt", + "tttii", + "tttii t", + "tttii tt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirt", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiit r", + "tttiiti", + "tttiitii", + "tttiitir", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrti", + "tttirrtr", + "tttirrtt", + "tttirt", + "tttirtir", + "tttirtit", + "tttirtrr", + "tttirtrt", + "tttirtt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit rr", + "tttit rt", + "tttit t", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirr", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrirrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrt t", + "tttrrti", + "tttrrtii", + "tttrrtir", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt t", + "tttrt i", + "tttrt ii", + "tttrt rr", + "tttrt rt", + "tttrt t", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrtii", + "tttrtiii", + "tttrtiit", + "tttrtirr", + "tttrtirt", + "tttrtit", + "tttrtiti", + "tttrtitr", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt r", + "tttrtt t", + "tttrtti", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt t", + "tttt i", + "tttt ii", + "tttt it", + "tttt rr", + "tttt rt", + "tttt t", + "tttt ti", + "tttt tr", + "tttt tt", + "tttt i", + "tttt ii", + "tttt iii", + "tttt iit", + "tttt rrr", + "tttt rrt", + "tttt rt", + "tttt rti", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt ti", + "tttt tii", + "tttt tit", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti r", + "tttti t", + "tttti tr", + "ttttii", + "ttttii i", + "ttttii t", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttit t", + "ttttiti", + "ttttitii", + "ttttitir", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtii", + "ttttrtir", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt i", + "ttttt ir", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti i", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr15": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i t", + "i it", + "i iii", + "i iiii", + "i iiiii", + "i rtit", + "i t", + "i ttiii", + "i ttitt", + "i ttttr", + "i ttttt", + "i i", + "i ii", + "i iii", + "i iiiii", + "i iiiiii", + "i iiitt", + "i iirrrr", + "i rrrtit", + "i rttt", + "i rtttrr", + "i t tr", + "i t iiii", + "i tittit", + "i tt", + "i tt t", + "i tt tt", + "i tttttt", + "ii", + "ii i", + "ii t", + "ii tt", + "ii t", + "ii ttt", + "ii tttt", + "ii ii rr", + "ii iiii", + "ii iiiii", + "ii iiit", + "ii t", + "ii titi", + "ii ttiti", + "iii", + "iii t", + "iii iiii", + "iii irrr", + "iii rrrr", + "iii rrt", + "iii tiii", + "iii titt", + "iiii", + "iiii t", + "iiii tt", + "iiii iii", + "iiii ti", + "iiii ttt", + "iiiii", + "iiiii ii", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiii t", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrr", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirtii", + "iiiirtir", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiit r", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitit", + "iiiititi", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrti", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitt t", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrtii", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrttr", + "iiirrttt", + "iiirt", + "iiirtiii", + "iiirtrrr", + "iiirtrrt", + "iiirtrtt", + "iiirtt", + "iiirtti", + "iiirttrr", + "iiirtttt", + "iiit", + "iiiti", + "iiitii", + "iiitiii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitirrr", + "iiitirrt", + "iiitit", + "iiititii", + "iiititrr", + "iiititrt", + "iiititti", + "iiitittt", + "iiitrrr", + "iiitrrrr", + "iiitrrrt", + "iiitrrt", + "iiitrrti", + "iiitrrtr", + "iiitrt", + "iiitrti", + "iiitrtii", + "iiitrtrr", + "iiitrtrt", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitt tt", + "iiitti", + "iiittiii", + "iiittiir", + "iiittiit", + "iiittirr", + "iiittirt", + "iiittit", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrt", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtrr", + "iirrrtrt", + "iirrrtti", + "iirrrttr", + "iirrrttt", + "iirrt", + "iirrti", + "iirrtiii", + "iirrtirr", + "iirrtiti", + "iirrtrrr", + "iirrtrti", + "iirrttii", + "iirrttrr", + "iirrtttt", + "iirt", + "iirtiiii", + "iirtiiir", + "iirtirrr", + "iirtirrt", + "iirtitit", + "iirtitrt", + "iirtrrrr", + "iirtrrtr", + "iirtrrtt", + "iirtrtrr", + "iirtrtt", + "iirtrttt", + "iirtt", + "iirttrrr", + "iirttrtr", + "iirttt", + "iirtttir", + "iirtttti", + "iirttttr", + "iirttttt", + "iit", + "iit trtr", + "iit tt", + "iit tttt", + "iiti", + "iitii", + "iitiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiit", + "iitiiiti", + "iitiiitr", + "iitiiitt", + "iitiit", + "iitiiti", + "iitiitii", + "iitiitit", + "iitiitt", + "iitiitti", + "iitiittr", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitit", + "iititiii", + "iititiit", + "iitititt", + "iititrrt", + "iititt", + "iititti", + "iitittii", + "iitittit", + "iitittrr", + "iitittti", + "iititttr", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrt", + "iitrrrtr", + "iitrrt", + "iitrrti", + "iitrrtrr", + "iitrrtt", + "iitrrtti", + "iitrrttt", + "iitrt", + "iitrti", + "iitrtrrr", + "iitrtrrt", + "iitrtrtr", + "iitrtti", + "iitrttii", + "iitrttrr", + "iitrtttt", + "iitt", + "iitti", + "iittii", + "iittiii", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiirt", + "iittiit", + "iittiiti", + "iittiitt", + "iittirrr", + "iittit", + "iittitii", + "iittitit", + "iittitt", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrtr", + "iittrrtt", + "iittrt", + "iittrt r", + "iittrtrr", + "iittrtrt", + "iittrttr", + "iittrttt", + "iittt", + "iittt t", + "iittt tt", + "iittti", + "iitttiii", + "iitttiir", + "iitttiit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttir", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "ir", + "irr", + "irrr", + "irrrrr", + "irrrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrt t", + "irrrrti", + "irrrrtii", + "irrrrtit", + "irrrrtr", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrti", + "irrrtiii", + "irrrtiti", + "irrrtitt", + "irrrtrrr", + "irrrtrti", + "irrrtrtt", + "irrrtt", + "irrrtti", + "irrrttii", + "irrrttr", + "irrrttrr", + "irrrttt", + "irrrtttt", + "irrt", + "irrti", + "irrtii", + "irrtiiii", + "irrtiirr", + "irrtirrr", + "irrtitti", + "irrtittr", + "irrtrrrr", + "irrtrrrt", + "irrtrrti", + "irrtrrtr", + "irrtrrtt", + "irrtrt", + "irrtrti", + "irrtrtii", + "irrtrtrr", + "irrtrtrt", + "irrtrtt", + "irrtrttt", + "irrtt", + "irrtt tt", + "irrttit", + "irrttitt", + "irrttrrr", + "irrttrrt", + "irrttrtr", + "irrttrtt", + "irrttt", + "irrtttrr", + "irrtttt", + "irrtttti", + "irrttttr", + "irrttttt", + "irt", + "irti", + "irtiiiti", + "irtiiitt", + "irtiitrr", + "irtiitt", + "irtiitti", + "irtirrtr", + "irtitit", + "irtitrrr", + "irtitt", + "irtrrrrr", + "irtrrrrt", + "irtrrrtr", + "irtrrrtt", + "irtrrt", + "irtrrtrr", + "irtrrtrt", + "irtrrttr", + "irtrrttt", + "irtrt", + "irtrtii", + "irtrtrrr", + "irtrtrt", + "irtrtrtr", + "irtrtt", + "irtrtttt", + "irtt", + "irtti", + "irttii", + "irttiitt", + "irttittt", + "irttrrrr", + "irttrrrt", + "irttrrtr", + "irttrt", + "irttrti", + "irttrtrt", + "irttrttt", + "irttt", + "irttti", + "irtttiti", + "irtttitt", + "irtttrrr", + "irtttrtr", + "irtttrtt", + "irtttt", + "irttttrr", + "irttttrt", + "irttttt", + "irtttttr", + "irtttttt", + "it", + "it r", + "it it", + "it ttt", + "it rttr", + "it i", + "it rrrrr", + "it rrt", + "it t", + "it t tt", + "it ttiii", + "it ttttt", + "iti", + "itii", + "itii ttt", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiirr", + "itiiiit", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiirrr", + "itiiiti", + "itiiitii", + "itiiitir", + "itiiitit", + "itiiitrr", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirrrt", + "itiirti", + "itiirtii", + "itiirtrr", + "itiit", + "itiitii", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiitrrr", + "itiitrrt", + "itiitrtr", + "itiitt", + "itiitti", + "itiittii", + "itiittit", + "itiittrr", + "itiittti", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirrrti", + "itirrrtt", + "itirtiii", + "itirttit", + "itirtttt", + "itit", + "ititi", + "ititiiii", + "ititiiit", + "ititiirt", + "ititiiti", + "ititiitt", + "ititirrr", + "itititi", + "itititii", + "itititit", + "itititt", + "itititti", + "ititittt", + "ititrtii", + "ititrttt", + "ititt", + "ititti", + "itittiii", + "itittiit", + "itittirt", + "itittitr", + "itittitt", + "itittt", + "itittti", + "ititttii", + "ititttit", + "ititttrr", + "ititttt", + "ititttti", + "itittttt", + "itrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrti", + "itrrrtit", + "itrrrtrr", + "itrrrtrt", + "itrrrtti", + "itrrrttr", + "itrrrttt", + "itrrt", + "itrrtiii", + "itrrtitt", + "itrrtrrr", + "itrrtrrt", + "itrrtrt", + "itrrtrtr", + "itrrtrtt", + "itrrtt", + "itrrttit", + "itrrttrr", + "itrrttrt", + "itrrttt", + "itrrtttr", + "itrrtttt", + "itrt", + "itrtii", + "itrtiiit", + "itrtiirr", + "itrtiitr", + "itrtiitt", + "itrtit", + "itrtitrt", + "itrtitti", + "itrtittt", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrt", + "itrtrtr", + "itrtrtrr", + "itrtrtrt", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrtt t", + "itrtti", + "itrttiti", + "itrttrrr", + "itrttrrt", + "itrttrt", + "itrttt", + "itrttti", + "itrtttrr", + "itrtttrt", + "itrtttt", + "itrtttti", + "itrttttt", + "itt", + "itt rr", + "itt ttt", + "itt i", + "itt rrtt", + "itt t", + "itt tiii", + "itt ttit", + "itti", + "ittii", + "ittiiii", + "ittiiiii", + "ittiiiit", + "ittiiirr", + "ittiiirt", + "ittiiiti", + "ittiiitt", + "ittiirtt", + "ittiit", + "ittiitii", + "ittiitit", + "ittiitrr", + "ittiitt", + "ittiittt", + "ittirrrr", + "ittirrtt", + "ittit", + "ittiti", + "ittitii", + "ittitiii", + "ittitiit", + "ittititi", + "ittititt", + "ittitrrr", + "ittitti", + "ittittii", + "ittittit", + "ittittrr", + "ittittt", + "ittittti", + "ittitttr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrtii", + "ittrrtrr", + "ittrrtrt", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrt rt", + "ittrtiti", + "ittrtitt", + "ittrtrrr", + "ittrtrrt", + "ittrtrtr", + "ittrtrtt", + "ittrttit", + "ittrttrr", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt ttt", + "ittti", + "ittti i", + "ittti tt", + "itttii", + "itttiii", + "itttiiii", + "itttiiit", + "itttiirr", + "itttiit", + "itttiiti", + "itttiitt", + "itttirt", + "itttirtt", + "itttiti", + "itttitii", + "itttitit", + "itttitrr", + "itttitt", + "itttitti", + "itttittt", + "itttrrrr", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrt t", + "itttrtrr", + "itttrtrt", + "itttrttr", + "itttrttt", + "itttt", + "itttt tt", + "itttti", + "itttti t", + "ittttii", + "ittttiii", + "ittttiit", + "ittttiti", + "ittttitr", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt t", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rirttttt", + "rr", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt i", + "rrrrt r", + "rrrrt t", + "rrrrt i", + "rrrrt r", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrti i", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtir", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt t", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt ti", + "rrrt tr", + "rrrt tt", + "rrrt i", + "rrrt it", + "rrrt itr", + "rrrt r", + "rrrt rr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t r", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiitr", + "rrrtiitt", + "rrrtirr", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtit t", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtr", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt t", + "rrrtt r", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttr", + "rrrttrr", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttr", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt i", + "rrt t", + "rrt rr", + "rrt t", + "rrt i", + "rrt r", + "rrt rrr", + "rrt rrt", + "rrt rt", + "rrt rtr", + "rrt rtt", + "rrt t", + "rrt ti", + "rrt trr", + "rrt trt", + "rrt tt", + "rrt i", + "rrt irrr", + "rrt r", + "rrt rrr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrti", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rt r", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rtti", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t t", + "rrt t rr", + "rrt t t", + "rrt ti", + "rrt tirr", + "rrt trrr", + "rrt trrt", + "rrt trt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt tt r", + "rrt tti", + "rrt ttrr", + "rrt ttrt", + "rrt ttt", + "rrt tttr", + "rrt tttt", + "rrti", + "rrtii", + "rrtii ii", + "rrtii t", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitii", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirtii", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirtt", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtit rt", + "rrtit t", + "rrtiti", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtitirt", + "rrtitit", + "rrtititi", + "rrtitrrr", + "rrtitrrt", + "rrtitrti", + "rrtitrtr", + "rrtitt", + "rrtittii", + "rrtittit", + "rrtittr", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtr", + "rrtrirrr", + "rrtrr", + "rrtrrr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt t", + "rrtrt r", + "rrtrt rr", + "rrtrt rt", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtiti", + "rrtrtitr", + "rrtrtitt", + "rrtrtr", + "rrtrtrr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt i", + "rrtt rr", + "rrtt rt", + "rrtt t", + "rrtt tr", + "rrtt tt", + "rrtt rrr", + "rrtt rrt", + "rrtt rtr", + "rrtt rtt", + "rrtt t", + "rrtt tit", + "rrtt trr", + "rrtt trt", + "rrtt tt", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrtti ti", + "rrttii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiiti", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttitii", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrr", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtr", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt t", + "rrttt rr", + "rrttt rt", + "rrttt t", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrr", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt i", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt i", + "rt r", + "rt t", + "rt r", + "rt rr", + "rt rt", + "rt tr", + "rt rrr", + "rt rt", + "rt t", + "rt t r", + "rt tr", + "rt trr", + "rt trt", + "rt ttr", + "rt ttt", + "rt it", + "rt rrrr", + "rt rrrt", + "rt rrt", + "rt rrtr", + "rt rt", + "rt rtrr", + "rt rtt", + "rt t", + "rt t r", + "rt t rt", + "rt trrr", + "rt trt", + "rt trti", + "rt trtr", + "rt tt", + "rt ttrr", + "rt ttt", + "rt i", + "rt irrrr", + "rt r", + "rt rrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrt r", + "rt rrti", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rt r", + "rt rt rr", + "rt rt rt", + "rt rt tr", + "rt rt tt", + "rt rtiii", + "rt rtrrr", + "rt rtrt", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rttit", + "rt rttrr", + "rt rttrt", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t rrr", + "rt t rrt", + "rt t t r", + "rt t trt", + "rt ti", + "rt trrr", + "rt trrrr", + "rt trrrt", + "rt trrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trt t", + "rt trtit", + "rt trtrr", + "rt trtrt", + "rt trtt", + "rt trtti", + "rt trttr", + "rt trttt", + "rt tt", + "rt tt r", + "rt tt rr", + "rt tt rt", + "rt tt ti", + "rt tt tt", + "rt ttrrr", + "rt ttrtt", + "rt ttt", + "rt tttit", + "rt tttrt", + "rt tttt", + "rt tttti", + "rt ttttr", + "rt ttttt", + "rti", + "rti rt", + "rti iiii", + "rti rrrr", + "rti tt", + "rtii", + "rtii rr", + "rtiii", + "rtiii ii", + "rtiii tr", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirt", + "rtiiirti", + "rtiiirtt", + "rtiiit", + "rtiiitii", + "rtiiitit", + "rtiiitrr", + "rtiiitti", + "rtiiittr", + "rtiirrrr", + "rtiirrrt", + "rtiirrti", + "rtiirrtr", + "rtiirrtt", + "rtiirt", + "rtiirtii", + "rtiirttr", + "rtiit", + "rtiitii", + "rtiitir", + "rtiitit", + "rtiititi", + "rtiititr", + "rtiitrrr", + "rtiitrrt", + "rtiitt", + "rtiittit", + "rtiittt", + "rtiitttr", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrti", + "rtirrtii", + "rtirrtrr", + "rtirrtt", + "rtirrttt", + "rtirt", + "rtirti", + "rtirtii", + "rtirtiii", + "rtirtitt", + "rtirtrr", + "rtirtrrr", + "rtirtrrt", + "rtirtrtr", + "rtirtrtt", + "rtirtt", + "rtirttii", + "rtirttit", + "rtirttrr", + "rtirttrt", + "rtirttt", + "rtirttti", + "rtirtttt", + "rtit", + "rtit rrr", + "rtiti", + "rtitiiit", + "rtitiirr", + "rtitiit", + "rtitiitr", + "rtitiitt", + "rtitirrr", + "rtitirrt", + "rtitirt", + "rtitirtr", + "rtitit", + "rtititit", + "rtititrr", + "rtititrt", + "rtititti", + "rtitittr", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrtr", + "rtitrrtt", + "rtitrtir", + "rtitrtrr", + "rtitrtt", + "rtitrtti", + "rtitrttr", + "rtitrttt", + "rtitt", + "rtitti", + "rtittiit", + "rtittirr", + "rtittirt", + "rtittitt", + "rtittrrr", + "rtittrrt", + "rtittrtr", + "rtittrtt", + "rtittt", + "rtitttir", + "rtitttit", + "rtitttrt", + "rtitttt", + "rtitttti", + "rtittttr", + "rtittttt", + "rtr", + "rtrr", + "rtrrr", + "rtrrrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt t", + "rtrrt i", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitt", + "rtrrtr", + "rtrrtrr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttr", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt r", + "rtrt t", + "rtrt r", + "rtrt rr", + "rtrt rt", + "rtrt t", + "rtrt tr", + "rtrt tt", + "rtrt i", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rtr", + "rtrt t r", + "rtrt trr", + "rtrt trt", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiirr", + "rtrtiiti", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirti", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtitii", + "rtrtitir", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtitti", + "rtrtittr", + "rtrtittt", + "rtrtr", + "rtrtrr", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtir", + "rtrtrtit", + "rtrtrtr", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt rr", + "rtrtt rt", + "rtrtt t", + "rtrtt tr", + "rtrtt tt", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttiit", + "rtrttirr", + "rtrttirt", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttr", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt r", + "rtt t", + "rtt rr", + "rtt t", + "rtt tr", + "rtt rrr", + "rtt rtr", + "rtt t", + "rtt trr", + "rtt ttt", + "rtt i", + "rtt rrrr", + "rtt rrrt", + "rtt rrtr", + "rtt rrtt", + "rtt rt", + "rtt rtrt", + "rtt rttt", + "rtt t", + "rtt ti", + "rtt tirr", + "rtt trrr", + "rtt trrt", + "rtt trtr", + "rtt trtt", + "rtt tt", + "rtt ttrr", + "rtt ttrt", + "rtt ttt", + "rtt tttr", + "rtt tttt", + "rtti", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiir", + "rttiiirr", + "rttiiirt", + "rttiiit", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirti", + "rttiirtt", + "rttiit", + "rttiiti", + "rttiitii", + "rttiitir", + "rttiitit", + "rttiitrr", + "rttiitti", + "rttiittr", + "rttirrrr", + "rttirrrt", + "rttirrt", + "rttirrti", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirti", + "rttirtit", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirtti", + "rttirttr", + "rttirttt", + "rttit", + "rttiti", + "rttitiii", + "rttititi", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrt", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttittii", + "rttittrt", + "rttittt", + "rttittti", + "rttitttt", + "rttr", + "rttrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrt t", + "rttrrti", + "rttrrtii", + "rttrrtir", + "rttrrtit", + "rttrrtr", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt r", + "rttrt t", + "rttrt rr", + "rttrt rt", + "rttrt t", + "rttrt ti", + "rttrt tr", + "rttrti", + "rttrtirr", + "rttrtirt", + "rttrtit", + "rttrtiti", + "rttrtitt", + "rttrtr", + "rttrtrr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtti", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt t", + "rttt rr", + "rttt t", + "rttt tr", + "rttt rrr", + "rttt rt", + "rttt rtt", + "rttt tt", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttii", + "rtttiii", + "rtttiiii", + "rtttiiit", + "rtttiirr", + "rtttiirt", + "rtttiit", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirr", + "rtttirrr", + "rtttirrt", + "rtttirt", + "rtttirti", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrr", + "rtttrrr", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrti", + "rtttrtir", + "rtttrtit", + "rtttrtr", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt i", + "rtttt ii", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrr", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttr", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t i", + "t r", + "t rr", + "t rt", + "t t", + "t tr", + "t tt", + "t i", + "t itt", + "t r", + "t rrr", + "t rt", + "t t", + "t t t", + "t tr", + "t trr", + "t trt", + "t tt", + "t ttt", + "t ii", + "t iiit", + "t itrr", + "t r", + "t rr", + "t rrr", + "t rrrr", + "t rrrt", + "t rrtr", + "t rt", + "t rtrr", + "t rttt", + "t t", + "t t r", + "t t t", + "t t rr", + "t t t", + "t t tt", + "t trr", + "t trrr", + "t trrt", + "t trt", + "t trtr", + "t trtt", + "t tt", + "t ttrr", + "t ttrt", + "t ttt", + "t tttt", + "t i", + "t iii i", + "t iiii", + "t iit", + "t itttt", + "t r", + "t rrr", + "t rrrr", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrti", + "t rrrtr", + "t rrrtt", + "t rrt", + "t rrti", + "t rrtrr", + "t rrtt", + "t rrttt", + "t rt", + "t rt t", + "t rti", + "t rtir", + "t rtrr", + "t rtrrr", + "t rtrrt", + "t rtrt", + "t rtrtr", + "t rtt", + "t rttrr", + "t rtttt", + "t t", + "t t r", + "t t t", + "t t r", + "t t rr", + "t t rt", + "t t rrr", + "t t tt", + "t ti", + "t ti t", + "t titti", + "t trr", + "t trrr", + "t trrrr", + "t trrrt", + "t trrt", + "t trrtr", + "t trrtt", + "t trt", + "t trt t", + "t trtr", + "t trtrr", + "t trtrt", + "t trtt", + "t trttr", + "t trttt", + "t tt", + "t tt r", + "t tt t", + "t tti", + "t tti t", + "t ttiii", + "t ttiir", + "t ttr", + "t ttrr", + "t ttrrt", + "t ttrtr", + "t ttrtt", + "t ttt", + "t tttrt", + "t tttt", + "t tttti", + "t ttttr", + "t ttttt", + "t i", + "t ii", + "t iiiiii", + "t iiiitt", + "t iiitrt", + "t iiittt", + "t iitit", + "t irrttr", + "t rr", + "t rrr", + "t rrrr", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrt r", + "t rrrti", + "t rrrtii", + "t rrrtir", + "t rrrtr", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrt tt", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrtt r", + "t rrtt t", + "t rrttt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt rr", + "t rt tr", + "t rt rr", + "t rt rrr", + "t rt rrt", + "t rt rt", + "t rt rtr", + "t rt rtt", + "t rt t t", + "t rtirrt", + "t rtr", + "t rtrrr", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrrti", + "t rtrrtr", + "t rtrrtt", + "t rtrt", + "t rtrti", + "t rtrtrr", + "t rtrtt", + "t rtrtti", + "t rtrttr", + "t rtrttt", + "t rtt", + "t rttii", + "t rttiii", + "t rttrrr", + "t rttrrt", + "t rttrtr", + "t rttrtt", + "t rttt", + "t rttt t", + "t rtttii", + "t rtttrr", + "t rtttrt", + "t rtttt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t t r", + "t t t", + "t t rrr", + "t t t", + "t t trt", + "t t tt", + "t t rr", + "t t rrrr", + "t t rrt", + "t t rt", + "t t rti", + "t t rtr", + "t t rtrr", + "t t rttt", + "t t t", + "t t t t", + "t t t r", + "t t trrr", + "t t trt", + "t t tt", + "t t ttir", + "t t ttt", + "t ti", + "t tii", + "t tiiiii", + "t tiiiit", + "t tiirrr", + "t tirrrr", + "t tit", + "t tittit", + "t titttt", + "t tr", + "t trrr", + "t trrrr", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrtr", + "t trrtrr", + "t trrttr", + "t trrttt", + "t trt", + "t trt r", + "t trt rr", + "t trt tt", + "t trti i", + "t trtr", + "t trtrr", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrtr", + "t trtrtt", + "t trtt", + "t trttrr", + "t trttrt", + "t trtttr", + "t trtttt", + "t tt", + "t tt rr", + "t tt t", + "t tt rrr", + "t tt rt", + "t tt t", + "t tt t t", + "t tt tt", + "t tt ttt", + "t tti tt", + "t ttiii", + "t ttiiii", + "t ttiitt", + "t ttirr", + "t ttirt", + "t ttit t", + "t ttitti", + "t ttittr", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrt", + "t ttrrtr", + "t ttrrtt", + "t ttrt", + "t ttrt t", + "t ttrtrt", + "t ttrtt", + "t ttrttt", + "t ttt", + "t ttt r", + "t ttt t", + "t ttt t", + "t ttti", + "t tttiii", + "t tttitt", + "t tttrrr", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttti", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti r", + "ti rrr", + "ti itit", + "ti tttt", + "ti iiii", + "ti iiiii", + "ti iiiit", + "ti ittt", + "ti rrrtr", + "ti t", + "ti t ttt", + "ti ttiii", + "ti tttit", + "ti tttrr", + "ti ttttt", + "tii", + "tii tt", + "tii tttt", + "tiii", + "tiiii", + "tiiii t", + "tiiiii", + "tiiiii t", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirti", + "tiiiirtt", + "tiiiit", + "tiiiit i", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrtr", + "tiiirrtt", + "tiiirti", + "tiiirtrr", + "tiiirtt", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitiii", + "tiiitiir", + "tiiitiit", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrt", + "tiiitrtt", + "tiiitt", + "tiiittii", + "tiiittir", + "tiiittit", + "tiiittrr", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrr", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrtii", + "tiirrtir", + "tiirrtit", + "tiirrtrr", + "tiirrtrt", + "tiirrtt", + "tiirrtti", + "tiirt", + "tiirt t", + "tiirtiii", + "tiirtrrr", + "tiirtrrt", + "tiirtrt", + "tiirttii", + "tiirttti", + "tiirtttt", + "tiit", + "tiiti", + "tiitii", + "tiitiiii", + "tiitiiir", + "tiitiirr", + "tiitiirt", + "tiitiit", + "tiitiiti", + "tiitiitt", + "tiitit", + "tiititii", + "tiititit", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrt", + "tiitrti", + "tiitrtrr", + "tiitrttt", + "tiitt", + "tiitt tt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiir", + "tiittiit", + "tiittit", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrt", + "tiittrtt", + "tiittt", + "tiittt i", + "tiittti", + "tiitttii", + "tiitttir", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrti", + "tirrrtii", + "tirrrtit", + "tirrrtrr", + "tirrrtrt", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrtiii", + "tirrtirt", + "tirrtit", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrt", + "tirrtrtt", + "tirrtt", + "tirrttit", + "tirrttrr", + "tirrttrt", + "tirrttti", + "tirrtttt", + "tirt", + "tirt tt", + "tirti", + "tirtii", + "tirtiiii", + "tirtiit", + "tirtiitr", + "tirtirrt", + "tirtirtr", + "tirtirtt", + "tirtit", + "tirtitit", + "tirtitt", + "tirtitti", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrrti", + "tirtrrtt", + "tirtrt", + "tirtrti", + "tirtrtrt", + "tirtrtt", + "tirtrttt", + "tirtt", + "tirtt tt", + "tirttiii", + "tirttiti", + "tirttitt", + "tirttrrr", + "tirttrrt", + "tirttrtr", + "tirttrtt", + "tirttt", + "tirtttit", + "tirtttrr", + "tirtttrt", + "tirtttti", + "tirttttr", + "tirttttt", + "tit", + "tit i", + "tit iiii", + "tit rttr", + "tit tt t", + "titi", + "titii", + "titii ti", + "titiii", + "titiiii", + "titiiiii", + "titiiiir", + "titiiiit", + "titiiirr", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirti", + "titiirtt", + "titiit", + "titiiti", + "titiitii", + "titiitir", + "titiitit", + "titiitrr", + "titiitrt", + "titiitt", + "titiitti", + "titiittr", + "titiittt", + "titirrrt", + "titirrti", + "titirrtr", + "titirtt", + "titit", + "titit ii", + "tititi", + "tititii", + "tititiii", + "tititiit", + "tititirt", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititrrt", + "tititrtr", + "tititrtt", + "tititt", + "tititti", + "titittii", + "titittit", + "titittrr", + "titittrt", + "titittt", + "titittti", + "tititttr", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrt", + "titrrrtt", + "titrrti", + "titrrtit", + "titrrtrr", + "titrrtrt", + "titrrttr", + "titrrttt", + "titrt", + "titrtirr", + "titrtrrr", + "titrtrrt", + "titrtrt", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrtti", + "titrttii", + "titrttrr", + "titrttrt", + "titrttt", + "titrttti", + "titrtttt", + "titt", + "titt rrr", + "titt tit", + "titti", + "titti ii", + "titti it", + "tittii", + "tittiiii", + "tittiiit", + "tittiit", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirrr", + "tittirtt", + "tittit", + "tittitii", + "tittitit", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrtr", + "tittrrtt", + "tittrt", + "tittrtit", + "tittrtt", + "tittrttt", + "tittt", + "tittt it", + "tittt ti", + "tittt tt", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttirr", + "titttirt", + "titttit", + "titttiti", + "titttitr", + "titttitt", + "titttrrr", + "titttrrt", + "titttrti", + "titttrtr", + "titttrtt", + "titttt", + "titttt t", + "titttti", + "tittttii", + "tittttir", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trr", + "trrr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt rr", + "trrrt rt", + "trrrt t", + "trrrt ti", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiir", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtiti", + "trrrtitt", + "trrrtr", + "trrrtrr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttr", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt rr", + "trrt t", + "trrt tr", + "trrt tt", + "trrt rrr", + "trrt rrt", + "trrt rtr", + "trrt t r", + "trrt trr", + "trrt trt", + "trrt ttt", + "trrti", + "trrtii", + "trrtiii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirr", + "trrtiirt", + "trrtiiti", + "trrtiitr", + "trrtirr", + "trrtirrr", + "trrtirrt", + "trrtirt", + "trrtirtr", + "trrtirtt", + "trrtit", + "trrtiti", + "trrtitit", + "trrtitrr", + "trrtitt", + "trrtitti", + "trrtittr", + "trrtittt", + "trrtr", + "trrtrr", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtr", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt rr", + "trrtt rt", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrttiii", + "trrttiir", + "trrttiit", + "trrttir", + "trrttirr", + "trrttirt", + "trrttiti", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt t", + "trrttti", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttr", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt t", + "trt rt", + "trt tr", + "trt rr", + "trt rrr", + "trt rt", + "trt t", + "trt t r", + "trt tii", + "trt trr", + "trt trt", + "trt ttt", + "trt iiir", + "trt rrrr", + "trt rrrt", + "trt rrtr", + "trt rrtt", + "trt rt", + "trt rt r", + "trt rtrr", + "trt rttr", + "trt rttt", + "trt t", + "trt t r", + "trt tit", + "trt trrr", + "trt trrt", + "trt trtr", + "trt trtt", + "trt tt", + "trt tt t", + "trt ttrr", + "trt ttrt", + "trt tttr", + "trt tttt", + "trti", + "trtii", + "trtii t", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiiiir", + "trtiiiit", + "trtiiirr", + "trtiiitt", + "trtiirrr", + "trtiirrt", + "trtiirt", + "trtiitii", + "trtiitit", + "trtiitrr", + "trtiittr", + "trtirrrr", + "trtirrrt", + "trtirrti", + "trtirtrr", + "trtirtrt", + "trtirtti", + "trtirttr", + "trtirttt", + "trtit", + "trtitiii", + "trtitiit", + "trtitirt", + "trtititt", + "trtitrrt", + "trtitrt", + "trtitrtt", + "trtitt", + "trtittii", + "trtittrr", + "trtittrt", + "trtittt", + "trtittti", + "trtitttt", + "trtr", + "trtrr", + "trtrrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrti", + "trtrrtir", + "trtrrtit", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt t", + "trtrt rr", + "trtrt rt", + "trtrt tr", + "trtrt tt", + "trtrti", + "trtrtiii", + "trtrtiir", + "trtrtir", + "trtrtirr", + "trtrtirt", + "trtrtit", + "trtrtitr", + "trtrtitt", + "trtrtr", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtti", + "trtrttii", + "trtrttir", + "trtrttit", + "trtrttr", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt t", + "trtt rr", + "trtt rt", + "trtt t", + "trtt tr", + "trtt tt", + "trtt rrr", + "trtt rrt", + "trtt rtr", + "trtt t", + "trtt t t", + "trtt ttr", + "trtt ttt", + "trtti", + "trttii", + "trttiii", + "trttiiii", + "trttiiit", + "trttiirr", + "trttiiti", + "trttiitt", + "trttirrr", + "trttirrt", + "trttirt", + "trttirtt", + "trttit", + "trttitii", + "trttitir", + "trttitrr", + "trttitrt", + "trttitt", + "trttitti", + "trttittr", + "trttittt", + "trttr", + "trttrr", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt t", + "trttrti", + "trttrtii", + "trttrtir", + "trttrtr", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt i", + "trttt t", + "trttt tr", + "trttt tt", + "trttti", + "trtttii", + "trtttiit", + "trtttirr", + "trtttirt", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttr", + "trtttrr", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt i", + "trtttt t", + "trtttti", + "trttttii", + "trttttit", + "trttttr", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt r", + "tt t", + "tt ii", + "tt rr", + "tt rt", + "tt t", + "tt tr", + "tt tt", + "tt i", + "tt iii", + "tt rr", + "tt rrr", + "tt rrt", + "tt rt", + "tt rtt", + "tt t", + "tt t r", + "tt trr", + "tt trt", + "tt tt", + "tt ttr", + "tt ttt", + "tt i", + "tt iii", + "tt irrr", + "tt itit", + "tt rrrr", + "tt rrrt", + "tt rrt", + "tt rrtt", + "tt rtrt", + "tt rtt", + "tt t", + "tt t t", + "tt t rr", + "tt t rt", + "tt tr", + "tt trt", + "tt tt", + "tt ttit", + "tt ttrr", + "tt ttt", + "tt ttti", + "tt tttr", + "tt tttt", + "tt i", + "tt i ii", + "tt ii", + "tt iiiii", + "tt iittt", + "tt it", + "tt ititt", + "tt ittti", + "tt itttt", + "tt rrrr", + "tt rrrrr", + "tt rrrrt", + "tt rrrt", + "tt rrrtr", + "tt rrrtt", + "tt rrt", + "tt rrt r", + "tt rrtir", + "tt rrtrr", + "tt rrtrt", + "tt rrtt", + "tt rrttr", + "tt rrttt", + "tt rt rr", + "tt rt tt", + "tt rtit", + "tt rtrr", + "tt rtrrr", + "tt rtrt", + "tt rtrtr", + "tt rtrtt", + "tt rtt", + "tt rttrr", + "tt rttrt", + "tt rtttr", + "tt rtttt", + "tt t", + "tt t t", + "tt t r", + "tt t rr", + "tt t rt", + "tt t t", + "tt t tr", + "tt t rr", + "tt t rrr", + "tt t rt", + "tt t t", + "tt t t r", + "tt t tr", + "tt t tt", + "tt ti", + "tt tirtr", + "tt titti", + "tt tittt", + "tt trrrr", + "tt trrrt", + "tt trrt", + "tt trrtr", + "tt trrtt", + "tt trt", + "tt trtrr", + "tt trtrt", + "tt trtti", + "tt trttr", + "tt trttt", + "tt tt", + "tt tt r", + "tt tt t", + "tt tt rt", + "tt tt t", + "tt tt tt", + "tt tti", + "tt ttirt", + "tt ttr", + "tt ttrrr", + "tt ttrrt", + "tt ttrt", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt ttti", + "tt tttii", + "tt tttit", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti t t", + "tti ttt", + "tti rrrr", + "tti tttt", + "ttii", + "ttii iii", + "ttii ttt", + "ttiii", + "ttiii ti", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtr", + "ttiiirtt", + "ttiiit", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtt", + "ttiirt", + "ttiirtrt", + "ttiirttr", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiitiii", + "ttiitiit", + "ttiitit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrtii", + "ttirrtit", + "ttirrtrr", + "ttirrtrt", + "ttirrtt", + "ttirrtti", + "ttirrttr", + "ttirrttt", + "ttirt", + "ttirti", + "ttirtirr", + "ttirtitt", + "ttirtrrr", + "ttirtrrt", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttir", + "ttirttit", + "ttirttrr", + "ttirttrt", + "ttirtttt", + "ttit", + "ttiti", + "ttitii", + "ttitiii", + "ttitiiii", + "ttitiiir", + "ttitiiit", + "ttitiirr", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirrr", + "ttitirti", + "ttitit", + "ttititi", + "ttititii", + "ttititit", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrt", + "ttitrrti", + "ttitrrtt", + "ttitrt", + "ttitrtit", + "ttitrtrr", + "ttitrtrt", + "ttitrtt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt t", + "ttitt tr", + "ttitti", + "ttitti t", + "ttittii", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrt", + "ttittrti", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt t", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttr", + "ttrr", + "ttrrr", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt r", + "ttrrt t", + "ttrrt rr", + "ttrrt rt", + "ttrrt tr", + "ttrrt tt", + "ttrrti", + "ttrrtii", + "ttrrtiii", + "ttrrtiir", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtiti", + "ttrrtitr", + "ttrrtitt", + "ttrrtr", + "ttrrtrr", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtti", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttr", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt t", + "ttrt rr", + "ttrt t", + "ttrt tr", + "ttrt rrr", + "ttrt rrt", + "ttrt rtr", + "ttrt rtt", + "ttrt trr", + "ttrt trt", + "ttrt ttr", + "ttrt ttt", + "ttrti", + "ttrtii", + "ttrtiiii", + "ttrtiiir", + "ttrtiiit", + "ttrtiit", + "ttrtirrr", + "ttrtirrt", + "ttrtirt", + "ttrtirtr", + "ttrtirtt", + "ttrtit", + "ttrtitii", + "ttrtitit", + "ttrtitrr", + "ttrtitrt", + "ttrtitt", + "ttrtitti", + "ttrtittt", + "ttrtrr", + "ttrtrrr", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt t", + "ttrtrti", + "ttrtrtii", + "ttrtrtir", + "ttrtrtit", + "ttrtrtr", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt rr", + "ttrtt tr", + "ttrtt tt", + "ttrtti", + "ttrttiii", + "ttrttiit", + "ttrttirr", + "ttrttiti", + "ttrttitr", + "ttrttitt", + "ttrttr", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrttti", + "ttrtttii", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt r", + "ttt t", + "ttt ii", + "ttt rr", + "ttt t", + "ttt ti", + "ttt tr", + "ttt tt", + "ttt iii", + "ttt it", + "ttt r", + "ttt rrr", + "ttt rrt", + "ttt rtr", + "ttt rtt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt trt", + "ttt tt", + "ttt tti", + "ttt ttt", + "ttt i", + "ttt irrr", + "ttt ittt", + "ttt rrrr", + "ttt rrrt", + "ttt rrtr", + "ttt rt t", + "ttt rtrr", + "ttt rtrt", + "ttt rttr", + "ttt rttt", + "ttt t", + "ttt t t", + "ttt t rr", + "ttt t tr", + "ttt t tt", + "ttt ti", + "ttt titt", + "ttt trrr", + "ttt trrt", + "ttt trt", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt tt r", + "ttt tt t", + "ttt tti", + "ttt ttii", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti rt", + "ttti tr", + "ttti i", + "ttti tti", + "ttti ttt", + "tttii", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrtr", + "tttirrtt", + "tttirt", + "tttirt t", + "tttirtrt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit ii", + "tttit ti", + "tttit tt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirr", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrr", + "tttitrrr", + "tttitrrt", + "tttitrt", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrr", + "tttrrr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrtii", + "tttrrtit", + "tttrrtr", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt rr", + "tttrt t", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrti t", + "tttrtii", + "tttrtiii", + "tttrtiit", + "tttrtirr", + "tttrtirt", + "tttrtit", + "tttrtitt", + "tttrtr", + "tttrtrr", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt i", + "tttrtt r", + "tttrtt t", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttr", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt t", + "tttt i", + "tttt it", + "tttt r", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt i", + "tttt iii", + "tttt iit", + "tttt irr", + "tttt itt", + "tttt rrr", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti t", + "tttti r", + "tttti rr", + "tttti t", + "tttti tt", + "ttttii", + "ttttii i", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirti", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrr", + "ttttrrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtii", + "ttttrtit", + "ttttrtr", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt i", + "ttttt r", + "ttttt t", + "ttttt i", + "ttttt ii", + "ttttt ir", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttir", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttr", + "tttttrr", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr16": [ + "-1", + "-2", + "-6", + "i", + "i t", + "i trrt", + "i tttt", + "i iiii", + "i t", + "i tt t", + "i tti", + "i ttiii", + "i iii", + "i iiiii", + "i iiiiii", + "i iiitit", + "i iiittt", + "i rrrrrr", + "i rt rt", + "i t", + "i tiii", + "i trtttt", + "i ttiiti", + "ii", + "ii rrrt", + "ii iiiii", + "ii iiitt", + "ii rtiti", + "ii rtttt", + "ii ttiii", + "ii ttti", + "ii ttttt", + "iii", + "iii tt", + "iii i", + "iii i", + "iii ii", + "iii iii", + "iii iiii", + "iii tr", + "iii ttii", + "iii ttti", + "iiii", + "iiii ti", + "iiii iii", + "iiii t", + "iiii tt", + "iiiii", + "iiiii i", + "iiiii ii", + "iiiii it", + "iiiiii", + "iiiiii i", + "iiiiii r", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiir", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiit t", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirtir", + "iiiirtrr", + "iiiirtrt", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiit tt", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiitirt", + "iiiitit", + "iiiititi", + "iiiititt", + "iiiitrr", + "iiiitrrr", + "iiiitrrt", + "iiiitrti", + "iiiitrtt", + "iiiitt", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrti", + "iiirrt", + "iiirrt r", + "iiirrtir", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrtti", + "iiirt", + "iiirtiii", + "iiirtirr", + "iiirtit", + "iiirtrrr", + "iiirtrt", + "iiirtrtr", + "iiirtt", + "iiirttrt", + "iiirtttt", + "iiit", + "iiit r", + "iiit rrr", + "iiit rtt", + "iiit t", + "iiiti", + "iiitii", + "iiitiiii", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitirrr", + "iiitit", + "iiititii", + "iiititrr", + "iiititt", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrt r", + "iiitrtir", + "iiitrtrr", + "iiitrttt", + "iiitt", + "iiitt t", + "iiitt tt", + "iiitti", + "iiittiii", + "iiittiir", + "iiittiit", + "iiittirr", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrt", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttir", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtit", + "iirrrtrr", + "iirrt", + "iirrtii", + "iirrtiii", + "iirrtit", + "iirrtrrr", + "iirrtrrt", + "iirrtrtr", + "iirrtrtt", + "iirrtt", + "iirrttii", + "iirrttt", + "iirrtttt", + "iirt", + "iirtii", + "iirtiiit", + "iirtiirr", + "iirtiiti", + "iirtiitt", + "iirtirrt", + "iirtiti", + "iirtrrrt", + "iirtrrtr", + "iirtrtii", + "iirtrtit", + "iirtrtti", + "iirtrttt", + "iirtt", + "iirtti", + "iirttiii", + "iirttitt", + "iirttrrt", + "iirttrtr", + "iirttrtt", + "iirtttii", + "iirtttrr", + "iirtttti", + "iirttttt", + "iit", + "iit t", + "iit rrrr", + "iit tiit", + "iit trtt", + "iit ttti", + "iit tttt", + "iiti", + "iitii", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiit", + "iitiiiti", + "iitiiitt", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitirrtr", + "iitirrtt", + "iitirtii", + "iitit", + "iititi", + "iititii", + "iititiii", + "iititiit", + "iititit", + "iitititt", + "iititrrr", + "iititrrt", + "iititt", + "iititti", + "iitittii", + "iitittit", + "iitittt", + "iitittti", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrtr", + "iitrrrtt", + "iitrrt r", + "iitrrti", + "iitrrtii", + "iitrrtir", + "iitrrtrr", + "iitrrttr", + "iitrrttt", + "iitrti", + "iitrtiii", + "iitrtrrr", + "iitrtrrt", + "iitrtrti", + "iitrtrtt", + "iitrtt", + "iitrttii", + "iitrttit", + "iitrttrr", + "iitrtttr", + "iitrtttt", + "iitt", + "iitti", + "iittii", + "iittiii", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiirt", + "iittiit", + "iittiiti", + "iittiitt", + "iittirrr", + "iittirt", + "iittirtt", + "iittit", + "iittitii", + "iittitit", + "iittitrt", + "iittitt", + "iittitti", + "iittittr", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrti", + "iittrrtr", + "iittrrtt", + "iittrtrr", + "iittrtt", + "iittrttr", + "iittrttt", + "iittt", + "iittt r", + "iittt t", + "iittti", + "iitttii", + "iitttiii", + "iitttiir", + "iitttiit", + "iitttirr", + "iitttit", + "iitttiti", + "iitttitr", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttt r", + "iitttti", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "ir", + "irr", + "irrr", + "irrrr", + "irrrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt r", + "irrrrtii", + "irrrrtir", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrti", + "irrrtit", + "irrrtr", + "irrrtrrr", + "irrrtrrt", + "irrrtrtt", + "irrrtt", + "irrrtti", + "irrrttii", + "irrrttit", + "irrrttrr", + "irrrttrt", + "irrrtttr", + "irrrtttt", + "irrt", + "irrt rrr", + "irrti", + "irrtiii", + "irrtiiii", + "irrtirrr", + "irrtit", + "irrtitrr", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrtrr", + "irrtrttt", + "irrtt", + "irrtti", + "irrttiit", + "irrttirr", + "irrttirt", + "irrttit", + "irrttrrr", + "irrttrrt", + "irrttrtt", + "irrttti", + "irrtttii", + "irrtttit", + "irrtttt", + "irrtttti", + "irrttttt", + "irt", + "irt trr", + "irt titr", + "irti", + "irtii", + "irtiiiti", + "irtiiitt", + "irtiitit", + "irtirrrr", + "irtirrrt", + "irtirttr", + "irtittii", + "irtittrr", + "irtr", + "irtrrrrr", + "irtrrrrt", + "irtrrt", + "irtrrtii", + "irtrrtrr", + "irtrrttt", + "irtrt", + "irtrtiii", + "irtrtrrr", + "irtrtrrt", + "irtrtrtt", + "irtrtt", + "irtrttii", + "irtrttit", + "irtrttt", + "irtrtttt", + "irtt", + "irtti", + "irttiii", + "irttiiii", + "irttiiti", + "irttirrr", + "irttittt", + "irttrrrr", + "irttrrtr", + "irttrtt", + "irttrttr", + "irttt", + "irttti", + "irtttitr", + "irtttrtt", + "irtttt", + "irttttii", + "irttttit", + "irttttrt", + "irttttti", + "irtttttt", + "it", + "it rrt", + "it rrrti", + "it tt", + "it ttiii", + "it tttti", + "it ttttt", + "iti", + "iti tttt", + "itii", + "itii i", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiirr", + "itiiiiti", + "itiiiitt", + "itiiirrr", + "itiiiti", + "itiiitii", + "itiiitit", + "itiiitrt", + "itiiitt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirrti", + "itiirt", + "itiirttt", + "itiit", + "itiitii", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiitrrt", + "itiitrt", + "itiitrtr", + "itiitrtt", + "itiitt", + "itiitti", + "itiittii", + "itiittit", + "itiittrr", + "itiittt", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrt", + "itirrrtr", + "itirrt", + "itirrt r", + "itirrttt", + "itirt", + "itirttit", + "itirtttt", + "itit", + "ititi", + "ititiii", + "ititiiii", + "ititiiit", + "ititiirt", + "ititiit", + "ititiiti", + "ititiitt", + "ititit", + "itititii", + "itititit", + "itititt", + "itititti", + "ititittr", + "ititittt", + "ititrrrr", + "ititrt", + "ititrtit", + "ititrttt", + "ititt", + "itittiii", + "itittiit", + "itittirt", + "itittit", + "itittiti", + "itittitt", + "itittt", + "itittt t", + "itittti", + "ititttii", + "ititttit", + "ititttti", + "itittttr", + "itittttt", + "itrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrtii", + "itrrrtrr", + "itrrrtrt", + "itrrrtti", + "itrrrttt", + "itrrt", + "itrrti", + "itrrtiii", + "itrrtiir", + "itrrtrrr", + "itrrtrrt", + "itrrtrtr", + "itrrtrtt", + "itrrtt", + "itrrttii", + "itrrttrr", + "itrrttrt", + "itrrttt", + "itrrtttr", + "itrrtttt", + "itrt", + "itrti", + "itrtiiii", + "itrtiit", + "itrtirrt", + "itrtitii", + "itrtitrr", + "itrtrrrr", + "itrtrrtr", + "itrtrrtt", + "itrtrtrt", + "itrtrtti", + "itrtrttt", + "itrtt", + "itrttitr", + "itrttrrr", + "itrttrrt", + "itrtttrr", + "itrtttrt", + "itrtttt", + "itrtttti", + "itrttttt", + "itt", + "itt ttr", + "itt irt", + "itt rrrr", + "itt t", + "itt tttt", + "itti", + "ittii", + "ittiii", + "ittiiii", + "ittiiiii", + "ittiiiir", + "ittiiiit", + "ittiiirr", + "ittiiiti", + "ittiiitr", + "ittiiitt", + "ittiit", + "ittiitii", + "ittiitit", + "ittiitti", + "ittiittt", + "ittirrtt", + "ittirtrr", + "ittirtrt", + "ittit", + "ittiti", + "ittiti i", + "ittitii", + "ittitiii", + "ittitiit", + "ittitit", + "ittititi", + "ittititt", + "ittitrrt", + "ittitrtt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittt", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrt r", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrtirr", + "ittrtitt", + "ittrtr", + "ittrtrrr", + "ittrtrt", + "ittrtrtr", + "ittrtrtt", + "ittrttrt", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt t", + "ittt t", + "ittt ttt", + "ittti", + "itttii", + "itttiii", + "itttiiii", + "itttiiit", + "itttiit", + "itttiiti", + "itttiitr", + "itttiitt", + "itttit", + "itttiti", + "itttitii", + "itttitit", + "itttitrr", + "itttitt", + "itttitti", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrtrr", + "itttrtrt", + "itttrtti", + "itttrttr", + "itttrttt", + "itttt", + "itttt tt", + "itttti", + "ittttii", + "ittttiii", + "ittttiir", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitr", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrti", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt t", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rr", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt it", + "rrrrt r", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt i", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt i", + "rrrt r", + "rrrt t", + "rrrt r", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt tr", + "rrrt tt", + "rrrt r", + "rrrt rr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t r", + "rrrt t t", + "rrrt ti", + "rrrt tr", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt tti", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti ir", + "rrrti rr", + "rrrtii", + "rrrtii t", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtr", + "rrrtritr", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt i", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt t", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttir", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttr", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt rr", + "rrt tr", + "rrt i", + "rrt it", + "rrt rrr", + "rrt rrt", + "rrt rt", + "rrt rtr", + "rrt rtt", + "rrt t", + "rrt trr", + "rrt trt", + "rrt tt", + "rrt ttt", + "rrt iiii", + "rrt iiit", + "rrt iiti", + "rrt rr", + "rrt rrr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrti", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rti", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t rt", + "rrt t tt", + "rrt ti", + "rrt tiit", + "rrt tirr", + "rrt trrr", + "rrt trrt", + "rrt trt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt ttii", + "rrt ttrr", + "rrt ttrt", + "rrt ttti", + "rrt tttt", + "rrti", + "rrtii", + "rrtii ii", + "rrtiii", + "rrtiii i", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitii", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrr", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirti", + "rrtirtii", + "rrtirtir", + "rrtirtrr", + "rrtirtrt", + "rrtirtt", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitii", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirt", + "rrtititi", + "rrtititr", + "rrtititt", + "rrtitrrr", + "rrtitrrt", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtitti", + "rrtittii", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtr", + "rrtrrr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt rt", + "rrtrt tt", + "rrtrti", + "rrtrti t", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtiti", + "rrtrtitr", + "rrtrtitt", + "rrtrtrr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt t", + "rrtt irt", + "rrtt rr", + "rrtt rrr", + "rrtt rrt", + "rrtt rt", + "rrtt rtr", + "rrtt rtt", + "rrtt t t", + "rrtt trr", + "rrtt trt", + "rrtt tt", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiit", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit r", + "rrttit t", + "rrttiti", + "rrttitii", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrr", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtr", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt rr", + "rrttt rt", + "rrttt tt", + "rrttti", + "rrttti i", + "rrtttii", + "rrtttiii", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttiti", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt t", + "rt ir", + "rt rrr", + "rt rti", + "rt rtr", + "rt t", + "rt trr", + "rt tt", + "rt it", + "rt rr", + "rt rrrr", + "rt rrrt", + "rt rrt", + "rt rrtr", + "rt rtr", + "rt rtrr", + "rt t", + "rt t r", + "rt t rr", + "rt trrr", + "rt trrt", + "rt trt", + "rt trtr", + "rt tt", + "rt tt r", + "rt tti", + "rt ttt", + "rt tttt", + "rt i", + "rt iiiir", + "rt irrrr", + "rt it", + "rt rrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrti", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrti", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rt rr", + "rt rt rt", + "rt rt tr", + "rt rtii", + "rt rtrrr", + "rt rtrrt", + "rt rtrt", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rttrr", + "rt rttrt", + "rt rttt", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t rrr", + "rt t t", + "rt t t t", + "rt t trr", + "rt ti", + "rt trrrr", + "rt trrrt", + "rt trt", + "rt trt r", + "rt trtrr", + "rt trtrt", + "rt trttt", + "rt tt", + "rt tt rr", + "rt tt tr", + "rt ttiii", + "rt ttrrr", + "rt ttrt", + "rt ttrtt", + "rt tttrr", + "rt tttt", + "rt tttti", + "rt ttttr", + "rt ttttt", + "rti", + "rti rrrr", + "rtii", + "rtii rt", + "rtiii", + "rtiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiit", + "rtiiitii", + "rtiiitrr", + "rtiiitt", + "rtiiittt", + "rtiirrrr", + "rtiirrt", + "rtiirrtr", + "rtiirrtt", + "rtiirt", + "rtiirt t", + "rtiirtii", + "rtiit", + "rtiiti t", + "rtiitii", + "rtiititi", + "rtiitrrr", + "rtiitrrt", + "rtiitrtt", + "rtiitt", + "rtiittii", + "rtiittrr", + "rtiittrt", + "rtiittt", + "rtiittti", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtii", + "rtirrtir", + "rtirrtrr", + "rtirrtrt", + "rtirrtti", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirt rr", + "rtirti", + "rtirtii", + "rtirtiii", + "rtirtirr", + "rtirtirt", + "rtirtitt", + "rtirtrrr", + "rtirtrrt", + "rtirtrt", + "rtirtrti", + "rtirtrtt", + "rtirtt", + "rtirttrr", + "rtirttrt", + "rtirttt", + "rtirtttr", + "rtirtttt", + "rtit", + "rtiti", + "rtitii", + "rtitiiii", + "rtitiirr", + "rtitirrr", + "rtitirti", + "rtitit", + "rtititi", + "rtititir", + "rtititit", + "rtititrr", + "rtititti", + "rtitittt", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrti", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtii", + "rtitrtrr", + "rtitrttr", + "rtitt", + "rtitti", + "rtittiii", + "rtittiit", + "rtittirr", + "rtittit", + "rtittitr", + "rtittitt", + "rtittrrr", + "rtittrtr", + "rtittrtt", + "rtittt", + "rtittti", + "rtitttii", + "rtitttt", + "rtitttti", + "rtittttt", + "rtrr", + "rtrrr", + "rtrrrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt t", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtirr", + "rtrrtiti", + "rtrrtitr", + "rtrrtitt", + "rtrrtr", + "rtrrtrr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt i", + "rtrrtti", + "rtrrttii", + "rtrrttit", + "rtrrttr", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt t", + "rtrt rr", + "rtrt tr", + "rtrt tt", + "rtrt rr", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rtr", + "rtrt t", + "rtrt trr", + "rtrt tt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiirt", + "rtrtiitr", + "rtrtirrr", + "rtrtirrt", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtiti", + "rtrtitii", + "rtrtitit", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtittr", + "rtrtittt", + "rtrtrr", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt t", + "rtrtt tt", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttiit", + "rtrttirr", + "rtrttit", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt r", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt t", + "rtt rr", + "rtt t", + "rtt rr", + "rtt rrr", + "rtt rrt", + "rtt rtr", + "rtt trr", + "rtt ttr", + "rtt ttt", + "rtt rrrr", + "rtt rrrt", + "rtt rrt", + "rtt rrtr", + "rtt rrtt", + "rtt rt", + "rtt rt r", + "rtt rtrr", + "rtt rtrt", + "rtt rtt", + "rtt t", + "rtt t rr", + "rtt t tt", + "rtt trrr", + "rtt trrt", + "rtt trt", + "rtt trtr", + "rtt tt", + "rtt ttrt", + "rtt ttt", + "rtt ttti", + "rtt tttr", + "rtt tttt", + "rtti", + "rtti rrr", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirti", + "rttiirtr", + "rttiitii", + "rttiitrr", + "rttiitrt", + "rttiitt", + "rttiitti", + "rttiittr", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrt", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirtti", + "rttirttt", + "rttit", + "rttitiii", + "rttitiit", + "rttitirr", + "rttitrrr", + "rttitrrt", + "rttitrt", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttittii", + "rttittrr", + "rttittrt", + "rttittti", + "rttitttr", + "rttitttt", + "rttr", + "rttrrr", + "rttrrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrt t", + "rttrrti", + "rttrrtii", + "rttrrtir", + "rttrrtit", + "rttrrtr", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt rr", + "rttrt t", + "rttrti", + "rttrtiii", + "rttrtirr", + "rttrtirt", + "rttrtitr", + "rttrtitt", + "rttrtrr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt r", + "rttrtt t", + "rttrtti", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt t", + "rttt tr", + "rttt tt", + "rttt iii", + "rttt rrr", + "rttt rtr", + "rttt t", + "rttt trt", + "rttt tt", + "rttt tti", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttii", + "rtttiii", + "rtttiiii", + "rtttiiit", + "rtttiirr", + "rtttiit", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirt", + "rtttirtt", + "rtttit t", + "rtttiti", + "rtttitii", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttr", + "rtttrrr", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrti", + "rtttrtii", + "rtttrtit", + "rtttrtr", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rtttti i", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrr", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt i", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttr", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t rr", + "t t", + "t tr", + "t iii", + "t rr", + "t rrr", + "t rrt", + "t rt", + "t rtr", + "t rtt", + "t t", + "t tr", + "t tt", + "t ttt", + "t iii", + "t r", + "t rr", + "t rrr", + "t rrrr", + "t rrrt", + "t rrt", + "t rt", + "t rt r", + "t rtr", + "t t", + "t t r", + "t t tt", + "t tr", + "t trrr", + "t trrt", + "t trtr", + "t ttt", + "t tttt", + "t i", + "t iii", + "t iiitt", + "t rr", + "t rrr", + "t rrrr", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrtt", + "t rrt", + "t rrtr", + "t rrtrr", + "t rrttt", + "t rt", + "t rt rt", + "t rti", + "t rtrr", + "t rtrt", + "t rtrtr", + "t rtrtt", + "t rtt", + "t rttrt", + "t rttt", + "t rtttt", + "t t", + "t t rr", + "t t t", + "t t tt", + "t t rr", + "t t rrr", + "t t rrt", + "t titt", + "t tittt", + "t trrrr", + "t trrtr", + "t trrtt", + "t trt", + "t trtrr", + "t trtt", + "t tt", + "t tt r", + "t tt t", + "t tti", + "t ttrrr", + "t ttt", + "t ttt t", + "t tttrt", + "t tttt", + "t tttti", + "t ttttt", + "t i", + "t ii", + "t iiiiii", + "t iiitit", + "t irrrrr", + "t itt", + "t rr", + "t rrr", + "t rrrr", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrt rt", + "t rrt tr", + "t rrtirr", + "t rrtrrr", + "t rrtrt", + "t rrtrtr", + "t rrtt", + "t rrttrt", + "t rrttt", + "t rrtttt", + "t rt", + "t rt r", + "t rt rt", + "t rt tr", + "t rt r", + "t rt rrt", + "t rt rt", + "t rti", + "t rtii", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrrtr", + "t rtrt", + "t rtrt r", + "t rtrtrt", + "t rtrtti", + "t rtrttt", + "t rtt", + "t rtt rr", + "t rtti", + "t rttrrr", + "t rttrrt", + "t rttrt", + "t rttrtr", + "t rttt", + "t rtttrt", + "t rttttt", + "t t", + "t t r", + "t t t", + "t t rt", + "t t t", + "t t r", + "t t rrr", + "t t rtr", + "t t trr", + "t t tt", + "t t rrr", + "t t rrrr", + "t t rt", + "t t t", + "t t t rt", + "t t t t", + "t t trrt", + "t t tt", + "t ti", + "t tiii", + "t tittr", + "t trrrr", + "t trrrrr", + "t trrrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrtrr", + "t trrttr", + "t trt", + "t trt rr", + "t trtrrr", + "t trtrrt", + "t trtrtr", + "t trttrr", + "t trttt", + "t tt", + "t tt r", + "t tt t", + "t tt rrr", + "t tt rtt", + "t tt t t", + "t tt tt", + "t ttii", + "t ttiiit", + "t ttittt", + "t ttrrr", + "t ttrrrr", + "t ttrrrt", + "t ttrrtt", + "t ttrtii", + "t ttrtt", + "t ttrtti", + "t ttrttt", + "t ttt", + "t ttt t", + "t tttiii", + "t tttitt", + "t tttrrr", + "t tttrti", + "t tttrtr", + "t tttt", + "t tttti", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t tttttr", + "t tttttt", + "ti", + "ti i", + "ti rrrr", + "ti t", + "ti tttt", + "ti i", + "ti iii", + "ti iiiii", + "ti rrttr", + "ti rtttt", + "ti tiiit", + "ti tiiti", + "ti trrtr", + "ti tt", + "ti ttrtt", + "ti tttti", + "tii", + "tii iii", + "tii rrt", + "tii tiit", + "tiii", + "tiii iii", + "tiiii", + "tiiii t", + "tiiiii", + "tiiiii r", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirtr", + "tiiiirtt", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirt", + "tiiirtii", + "tiiirtti", + "tiiirttr", + "tiiirttt", + "tiiit", + "tiiit tt", + "tiiiti", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitirr", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrt r", + "tiirrtrr", + "tiirrtrt", + "tiirrtt", + "tiirrtti", + "tiirrttt", + "tiirtiii", + "tiirtirt", + "tiirtiti", + "tiirtrrr", + "tiirtrrt", + "tiirtrt", + "tiirtt r", + "tiirttti", + "tiirtttt", + "tiit", + "tiiti", + "tiitii", + "tiitiiii", + "tiitiiir", + "tiitiiit", + "tiitiirt", + "tiitiiti", + "tiitiitr", + "tiitiitt", + "tiitirrr", + "tiitirrt", + "tiitit", + "tiitit i", + "tiititi", + "tiititii", + "tiititit", + "tiititrr", + "tiititt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrtit", + "tiitrttt", + "tiitt", + "tiittii", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrtt", + "tiittt", + "tiittti", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtii", + "tirrrtit", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrttt", + "tirrt", + "tirrtii", + "tirrtiii", + "tirrtirr", + "tirrtrrr", + "tirrtrt", + "tirrtrtr", + "tirrtt", + "tirrtti", + "tirrttii", + "tirrttit", + "tirrttrr", + "tirrttt", + "tirrttti", + "tirrtttt", + "tirt", + "tirtiii", + "tirtiirr", + "tirtirrt", + "tirtiti", + "tirtitrt", + "tirtrrrr", + "tirtrrrt", + "tirtrrtr", + "tirtrt", + "tirtrtii", + "tirtrtrt", + "tirtt", + "tirtti", + "tirttiii", + "tirttiit", + "tirttirr", + "tirttrrr", + "tirttrrt", + "tirttrti", + "tirttrtt", + "tirttt", + "tirtttt", + "tirtttti", + "tirttttr", + "tirttttt", + "tit", + "tit tir", + "tit ttt", + "tit irrr", + "tit tttt", + "titi", + "titii", + "titii t", + "titiii", + "titiiii", + "titiiiii", + "titiiiir", + "titiiiit", + "titiiirr", + "titiiit", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirrt", + "titiitii", + "titiitit", + "titiittr", + "titiittt", + "titirrrr", + "titirrt", + "titirrtt", + "titirt", + "titirtir", + "titirttt", + "titit", + "tititi", + "tititiii", + "tititiit", + "tititirr", + "tititirt", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititrrt", + "tititrt", + "tititrtr", + "tititrtt", + "tititt", + "tititt t", + "tititti", + "titittii", + "titittit", + "titittrr", + "titittrt", + "titittt", + "titittti", + "tititttr", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrtrt", + "titrrtt", + "titrrttr", + "titrrttt", + "titrt", + "titrtii", + "titrtiii", + "titrtiir", + "titrtitt", + "titrtrrr", + "titrtrrt", + "titrtrtt", + "titrttii", + "titrtttt", + "titt", + "titti", + "tittii", + "tittiiii", + "tittiiir", + "tittiiit", + "tittiirr", + "tittiirt", + "tittiit", + "tittiiti", + "tittiitt", + "tittirrt", + "tittirti", + "tittirtt", + "tittiti", + "tittitii", + "tittitit", + "tittitrt", + "tittitt", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrti", + "tittrrtr", + "tittrrtt", + "tittrtit", + "tittrtrt", + "tittrttr", + "tittrttt", + "tittt", + "tittt i", + "tittt t", + "tittt tt", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttirr", + "titttirt", + "titttit", + "titttiti", + "titttitr", + "titttitt", + "titttrrr", + "titttrrt", + "titttrt", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttir", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trittttt", + "trr", + "trrr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt i", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt r", + "trrrt rr", + "trrrt rt", + "trrrt tr", + "trrrti", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtiti", + "trrrtitr", + "trrrtitt", + "trrrtrr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttit", + "trrrttr", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt r", + "trrt t", + "trrt rr", + "trrt t", + "trrt tr", + "trrt rrr", + "trrt rrt", + "trrt rtr", + "trrt rtt", + "trrt t", + "trrt trr", + "trrt trt", + "trrt tt", + "trrt ttt", + "trrti", + "trrtiiii", + "trrtiiir", + "trrtiirr", + "trrtiiti", + "trrtirrr", + "trrtirrt", + "trrtirtr", + "trrtirtt", + "trrtit", + "trrtitii", + "trrtittr", + "trrtittt", + "trrtr", + "trrtrr", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrt t", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtr", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt r", + "trrtt t", + "trrtt rt", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrtti r", + "trrttiii", + "trrttirr", + "trrttitr", + "trrttitt", + "trrttrr", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrttt t", + "trrttti", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt i", + "trt r", + "trt rr", + "trt rt", + "trt tr", + "trt rrr", + "trt rrt", + "trt t", + "trt tr", + "trt trr", + "trt trt", + "trt ttr", + "trt rrrr", + "trt rrrt", + "trt rrt", + "trt rrtr", + "trt rrtt", + "trt rtii", + "trt rttt", + "trt t", + "trt trrr", + "trt trrt", + "trt trt", + "trt ttrr", + "trt tttt", + "trti", + "trtii", + "trtiii", + "trtiiiii", + "trtiiiit", + "trtiiirr", + "trtiiirt", + "trtiiiti", + "trtiirrr", + "trtiit", + "trtiit r", + "trtiittt", + "trtirrrr", + "trtirrtt", + "trtirt", + "trtirttr", + "trtirttt", + "trtit", + "trtitii", + "trtitiir", + "trtititr", + "trtitrr", + "trtitrrr", + "trtitrti", + "trtitrtr", + "trtitt t", + "trtittrr", + "trtittrt", + "trtittt", + "trtitttr", + "trtitttt", + "trtrr", + "trtrrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrti", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt rr", + "trtrt rt", + "trtrt tr", + "trtrt tt", + "trtrti", + "trtrtii", + "trtrtiii", + "trtrtirr", + "trtrtitr", + "trtrtitt", + "trtrtr", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtti", + "trtrttii", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rr", + "trtt t", + "trtt tt", + "trtt rr", + "trtt rrr", + "trtt rtr", + "trtt rtt", + "trtt t", + "trtt trr", + "trtt tt", + "trtt ttt", + "trtti", + "trttiii", + "trttiiii", + "trttiirr", + "trttiit", + "trttirrr", + "trttirrt", + "trttirt", + "trttirtt", + "trttit", + "trttitit", + "trttitrt", + "trttitt", + "trttittr", + "trttittt", + "trttr", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrti", + "trttrtii", + "trttrtit", + "trttrtr", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrttr", + "trttrttt", + "trttt", + "trttt rt", + "trttt tt", + "trttti", + "trtttii", + "trtttiii", + "trtttiit", + "trtttirr", + "trtttit", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttr", + "trtttrr", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttt t", + "trtttti", + "trttttii", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt r", + "tt t", + "tt it", + "tt r", + "tt rr", + "tt t", + "tt tt", + "tt rrr", + "tt rrt", + "tt rt", + "tt rtr", + "tt rtt", + "tt t", + "tt t t", + "tt ii", + "tt iii", + "tt rr", + "tt rrr", + "tt rrrr", + "tt rrrt", + "tt rrt", + "tt rrtr", + "tt rt", + "tt rttt", + "tt t", + "tt t t", + "tt trrr", + "tt trt", + "tt trtt", + "tt tt", + "tt ttr", + "tt ttrt", + "tt ttt", + "tt ttti", + "tt tttt", + "tt i", + "tt iiii", + "tt iiiii", + "tt iiiit", + "tt iitti", + "tt rrrrr", + "tt rrrrt", + "tt rrrtr", + "tt rrrtt", + "tt rrt r", + "tt rrtrr", + "tt rrtrt", + "tt rrtt", + "tt rrttt", + "tt rt t", + "tt rt rr", + "tt rt t", + "tt rtrr", + "tt rtrrt", + "tt rtrtt", + "tt rttrr", + "tt rttrt", + "tt rtttt", + "tt t", + "tt t tt", + "tt t rr", + "tt t rt", + "tt t trr", + "tt t ttr", + "tt tii", + "tt tiiii", + "tt tiiti", + "tt trrrr", + "tt trrrt", + "tt trrti", + "tt trrtr", + "tt trrtt", + "tt trt r", + "tt trtrr", + "tt trtrt", + "tt trtti", + "tt trttt", + "tt tt", + "tt tt t", + "tt tt tt", + "tt tti", + "tt ttitr", + "tt ttrrr", + "tt ttrrt", + "tt ttrt", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt ttti", + "tt tttit", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti t", + "tti rrr", + "tti ttr", + "tti i", + "tti iiii", + "tti t tt", + "tti tii", + "tti tttt", + "ttii", + "ttii tti", + "ttiii", + "ttiii ii", + "ttiiii", + "ttiiii i", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtt", + "ttiiit", + "ttiiiti", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitti", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtr", + "ttiirtii", + "ttiirtr", + "ttiirtrr", + "ttiirtrt", + "ttiirttr", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiiti t", + "ttiitii", + "ttiitiii", + "ttiitiit", + "ttiitirr", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitt t", + "ttiitti", + "ttiittii", + "ttiittir", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrti", + "ttirrrtt", + "ttirrt", + "ttirrt r", + "ttirrtii", + "ttirrtit", + "ttirrtrr", + "ttirrtrt", + "ttirrtt", + "ttirrttt", + "ttirt", + "ttirti", + "ttirtirr", + "ttirtitt", + "ttirtrtr", + "ttirtt", + "ttirtti", + "ttirttii", + "ttirttrr", + "ttirttrt", + "ttirttti", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit iii", + "ttit iti", + "ttit ttt", + "ttiti", + "ttitii", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirrt", + "ttitirti", + "ttitirtr", + "ttitirtt", + "ttitit", + "ttititi", + "ttititii", + "ttititit", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrt", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtir", + "ttitrtrr", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt t", + "ttitt tt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrti", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttr", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrr", + "ttrrrr", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrti", + "ttrrrtii", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt r", + "ttrrt rr", + "ttrrt tt", + "ttrrti", + "ttrrtiii", + "ttrrtiir", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtitt", + "ttrrtrr", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttr", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt tr", + "ttrt tt", + "ttrt rrr", + "ttrt rtt", + "ttrt t", + "ttrt trr", + "ttrt ttt", + "ttrti", + "ttrti r", + "ttrtii", + "ttrtiii", + "ttrtiiii", + "ttrtiiir", + "ttrtiiit", + "ttrtiirr", + "ttrtiirt", + "ttrtiitt", + "ttrtirrr", + "ttrtirrt", + "ttrtirti", + "ttrtiti", + "ttrtittr", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrtii", + "ttrtrtir", + "ttrtrtit", + "ttrtrtr", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt t", + "ttrtt rr", + "ttrtti", + "ttrttii", + "ttrttiii", + "ttrttiit", + "ttrttirr", + "ttrttirt", + "ttrttit", + "ttrttiti", + "ttrttitt", + "ttrttrr", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttti", + "ttrtttii", + "ttrtttir", + "ttrtttit", + "ttrtttr", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt r", + "ttt t", + "ttt rt", + "ttt t", + "ttt tt", + "ttt iii", + "ttt rrr", + "ttt rrt", + "ttt rtt", + "ttt t", + "ttt trr", + "ttt trt", + "ttt tt", + "ttt tti", + "ttt ttr", + "ttt ttt", + "ttt iiit", + "ttt iitt", + "ttt it", + "ttt itii", + "ttt ittt", + "ttt rrrr", + "ttt rrtr", + "ttt rt r", + "ttt rt t", + "ttt rtrt", + "ttt rttt", + "ttt t", + "ttt t t", + "ttt t tr", + "ttt t tt", + "ttt titt", + "ttt trrr", + "ttt trrt", + "ttt trtt", + "ttt tt", + "ttt tt t", + "ttt tti", + "ttt ttit", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt ttti", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti t", + "ttti tti", + "tttii", + "tttii ii", + "tttii tt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitir", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrti", + "tttirrtr", + "tttirrtt", + "tttirt", + "tttirtrr", + "tttirtrt", + "tttirtti", + "tttirttt", + "tttit", + "tttit ii", + "tttit rr", + "tttit tt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiir", + "tttitiit", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitt t", + "tttitti", + "tttittii", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrrr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrti", + "tttrrtir", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt r", + "tttrt rr", + "tttrt tr", + "tttrti", + "tttrtiit", + "tttrtirr", + "tttrtitr", + "tttrtitt", + "tttrtr", + "tttrtrrr", + "tttrtrrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt r", + "tttrtt t", + "tttrtti", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttr", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt i", + "tttt r", + "tttt t", + "tttt ii", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt i", + "tttt i t", + "tttt iii", + "tttt itt", + "tttt rr", + "tttt rrr", + "tttt rrt", + "tttt rt", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt tit", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt ttt", + "tttti", + "tttti t", + "tttti ti", + "tttti tt", + "ttttii", + "ttttii i", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirti", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttr", + "ttttritt", + "ttttrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtir", + "ttttrtit", + "ttttrtr", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr17": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i r", + "i t", + "i i", + "i ii", + "i it", + "i rr", + "i t", + "i ti", + "i tr", + "i tt", + "i i", + "i iii", + "i irr", + "i it", + "i itt", + "i rrr", + "i rtr", + "i t", + "i trt", + "i tti", + "i ttr", + "i ttt", + "i i", + "i i t", + "i i i", + "i i rt", + "i ii", + "i iii", + "i iiii", + "i iirr", + "i irrr", + "i irrt", + "i irti", + "i irtr", + "i irtt", + "i iti", + "i itii", + "i itt", + "i itti", + "i ittt", + "i rrrr", + "i rrtr", + "i rtrt", + "i tt", + "i ttit", + "i tttr", + "i tttt", + "i i", + "i i ii", + "i i iii", + "i i rrt", + "i ii", + "i iii", + "i iiii", + "i iiiii", + "i iiiit", + "i iiiti", + "i iirrr", + "i iirrt", + "i iit r", + "i iitrr", + "i iitti", + "i iittt", + "i irrrr", + "i irrrt", + "i irrt", + "i irrtr", + "i irrtt", + "i irt", + "i irt r", + "i irtrr", + "i irtrt", + "i irttt", + "i it", + "i it ii", + "i itiii", + "i ititt", + "i itrrr", + "i itrrt", + "i itrtr", + "i itrtt", + "i itt", + "i ittir", + "i ittit", + "i ittrr", + "i ittrt", + "i ittt", + "i ittti", + "i itttr", + "i itttt", + "i rrrrr", + "i rrrrt", + "i t rtt", + "i t trr", + "i trrtt", + "i trttt", + "i tt tt", + "i ttiit", + "i ttrrr", + "i tttii", + "i tttrr", + "i tttrt", + "i ttttt", + "i i", + "i i i", + "i i iiii", + "i i rrrr", + "i i rrrt", + "i ii", + "i ii iii", + "i iiii", + "i iiii t", + "i iiiiii", + "i iiiiit", + "i iiiiti", + "i iiiitt", + "i iiirrr", + "i iiitii", + "i iiitrr", + "i iiittt", + "i iirrrr", + "i iirrrt", + "i iirrtr", + "i iitiit", + "i iititi", + "i iittrr", + "i iittrt", + "i iittti", + "i iitttt", + "i irrrrr", + "i irrrrt", + "i irrrt", + "i irrrtr", + "i irrtrt", + "i irrttt", + "i irtrtr", + "i irttit", + "i irtttt", + "i it", + "i it rrr", + "i itiiii", + "i itittt", + "i itrrrr", + "i itrrt", + "i itrrtr", + "i itrrtt", + "i itrt", + "i itrt r", + "i itrtrt", + "i itrttt", + "i itt", + "i itti", + "i ittitt", + "i ittrrr", + "i ittt", + "i itttrt", + "i itttti", + "i ittttr", + "i ittttt", + "i rrrrrr", + "i rrrtir", + "i rrtrti", + "i rrtt t", + "i rrttii", + "i rtiiii", + "i rtrrrr", + "i rtrrtr", + "i rttrtr", + "i rttttr", + "i rttttt", + "i t", + "i t t", + "i t rrr", + "i t trrt", + "i tiiiii", + "i trrrrr", + "i trrrrt", + "i trrrtr", + "i trtrrt", + "i trttrt", + "i trtttr", + "i tt", + "i tt rtt", + "i ttrrrr", + "i ttrtrt", + "i ttt", + "i tttrrt", + "i tttrtt", + "i ttttii", + "i ttttit", + "i ttttrr", + "i ttttrt", + "i ttttt", + "i ttttti", + "i tttttt", + "ii", + "ii ii", + "ii t", + "ii ttt", + "ii iiii", + "ii tttt", + "ii i", + "ii ii", + "ii iiiii", + "ii iiitt", + "ii t", + "ii trrtr", + "ii tt", + "ii ttiii", + "ii ttitt", + "ii ttrtt", + "ii tttti", + "ii ttttt", + "iii", + "iii i", + "iii i ii", + "iii ii", + "iii iiii", + "iii iiit", + "iii iirr", + "iii ittr", + "iii ittt", + "iii t", + "iii tiii", + "iii ttti", + "iii tttt", + "iiii", + "iiii t", + "iiii i", + "iiii ii", + "iiii ii", + "iiii iii", + "iiii iit", + "iiii itr", + "iiii rrr", + "iiii rrt", + "iiii t", + "iiii trr", + "iiii tt", + "iiii tti", + "iiii ttr", + "iiii ttt", + "iiiii", + "iiiii r", + "iiiii i", + "iiiii ii", + "iiiii it", + "iiiii rr", + "iiiii t", + "iiiii tr", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiii t", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirt t", + "iiiirtii", + "iiiirtir", + "iiiirtrt", + "iiiirtti", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiitit", + "iiiititi", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrti", + "iiiitrtt", + "iiiitt", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt r", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrttt", + "iiirt", + "iiirt rr", + "iiirti", + "iiirtiii", + "iiirtiir", + "iiirtiit", + "iiirtrrr", + "iiirtrti", + "iiirtrtr", + "iiirtt", + "iiirttii", + "iiirttrr", + "iiirttrt", + "iiirtttt", + "iiit", + "iiit iii", + "iiit rrr", + "iiit tit", + "iiit trt", + "iiit ttt", + "iiiti", + "iiitii", + "iiitiiii", + "iiitiiit", + "iiitiiti", + "iiitiitt", + "iiitirrr", + "iiitit", + "iiititii", + "iiititit", + "iiititrr", + "iiititt", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrti", + "iiitrtit", + "iiitrtrr", + "iiitrtrt", + "iiitrtti", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitt t", + "iiitt tt", + "iiitti", + "iiittiii", + "iiittiit", + "iiittirr", + "iiittit", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttir", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrti", + "iirrrtit", + "iirrrtrr", + "iirrrtrt", + "iirrrtti", + "iirrrttr", + "iirrrttt", + "iirrt", + "iirrtiii", + "iirrtiti", + "iirrtrrr", + "iirrtrrt", + "iirrtrtr", + "iirrtrtt", + "iirrtt", + "iirrttii", + "iirrttrr", + "iirrttrt", + "iirrttt", + "iirrttti", + "iirrtttr", + "iirrtttt", + "iirt", + "iirt rrt", + "iirt tii", + "iirtiiii", + "iirtiiit", + "iirtiirt", + "iirtirrr", + "iirtirrt", + "iirtitir", + "iirtittt", + "iirtrrrr", + "iirtrrtr", + "iirtrtrr", + "iirtrtrt", + "iirtt", + "iirttiii", + "iirttiit", + "iirttrrr", + "iirttrrt", + "iirttt", + "iirtttrr", + "iirtttt", + "iirttttt", + "iit", + "iit rtrt", + "iit rttt", + "iit t", + "iit tttt", + "iiti", + "iitii", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiit", + "iitiiirt", + "iitiiiti", + "iitiiitt", + "iitiirrr", + "iitiirtt", + "iitiit", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitirrtt", + "iitirtt", + "iitirttt", + "iitit", + "iititi", + "iititiii", + "iititiit", + "iititirr", + "iitititi", + "iitititt", + "iititrrt", + "iititrti", + "iititt", + "iitittii", + "iitittit", + "iitittrr", + "iitittti", + "iititttr", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrtt", + "iitrrt", + "iitrrtrt", + "iitrrtt", + "iitrrtti", + "iitrrttt", + "iitrt", + "iitrt rr", + "iitrti", + "iitrtrrr", + "iitrtrti", + "iitrtrtr", + "iitrtrtt", + "iitrtt", + "iitrttrr", + "iitrttrt", + "iitrtttr", + "iitrtttt", + "iitt", + "iitt ttt", + "iitti", + "iittii", + "iittiiii", + "iittiiit", + "iittiirr", + "iittiiti", + "iittiitt", + "iittirtt", + "iittit", + "iittitii", + "iittitit", + "iittitt", + "iittittt", + "iittrrrt", + "iittrrtr", + "iittrrtt", + "iittrtrr", + "iittrtrt", + "iittrttr", + "iittrttt", + "iittt", + "iittt t", + "iittti", + "iitttii", + "iitttiii", + "iitttiit", + "iitttirt", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrt t", + "irrrrtii", + "irrrrtir", + "irrrrtit", + "irrrrtrr", + "irrrrtrt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrti", + "irrrtiii", + "irrrtiti", + "irrrtitr", + "irrrtitt", + "irrrtrrr", + "irrrtrrt", + "irrrtrt", + "irrrtrti", + "irrrtrtr", + "irrrtrtt", + "irrrtt", + "irrrttii", + "irrrttrt", + "irrrttt", + "irrrttti", + "irrrtttt", + "irrt", + "irrt rrr", + "irrti", + "irrtiiii", + "irrtiit", + "irrtiitt", + "irrtirrr", + "irrtitti", + "irrtittt", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrti", + "irrtrrtr", + "irrtrtrr", + "irrtrtt", + "irrtrttr", + "irrtrttt", + "irrtt", + "irrtt t", + "irrtt tt", + "irrttiit", + "irrttirr", + "irrttit", + "irrttrrr", + "irrttrrt", + "irrttrtt", + "irrttt t", + "irrtttii", + "irrtttrr", + "irrtttrt", + "irrtttt", + "irrtttti", + "irrttttr", + "irrttttt", + "irt", + "irt rr", + "irt rtrt", + "irt t", + "irt ttii", + "irt tttt", + "irti", + "irti itt", + "irtiii", + "irtiiiii", + "irtiiiit", + "irtiiit", + "irtiiiti", + "irtirrrr", + "irtirrtt", + "irtirti", + "irtitttt", + "irtrrrrr", + "irtrrrrt", + "irtrrrti", + "irtrrrtr", + "irtrrrtt", + "irtrrt", + "irtrrtrr", + "irtrrtrt", + "irtrrttr", + "irtrrttt", + "irtrt", + "irtrt t", + "irtrt tr", + "irtrtitt", + "irtrtrrr", + "irtrtrrt", + "irtrtrtr", + "irtrtrtt", + "irtrttit", + "irtrttrr", + "irtrttrt", + "irtrttti", + "irtrtttr", + "irtrtttt", + "irtt", + "irtt rrr", + "irtti", + "irttiiii", + "irttiirr", + "irttirrr", + "irttirrt", + "irttit", + "irttrrrr", + "irttrrrt", + "irttrrtt", + "irttrt", + "irttrtrt", + "irttrttr", + "irttrttt", + "irttt", + "irttt rr", + "irtttiii", + "irtttitt", + "irtttrrr", + "irtttrtr", + "irtttt", + "irttttii", + "irttttit", + "irttttrr", + "irttttrt", + "irttttt", + "irttttti", + "irtttttr", + "irtttttt", + "it", + "it t", + "it ii", + "it rt", + "it t", + "it rrr", + "it itt", + "it rrrr", + "it t t", + "it i", + "it iiiir", + "it ititt", + "it itrtr", + "it ittit", + "it rt", + "it rtttt", + "it t", + "it t tt", + "it tiiir", + "it ttrrr", + "it tttti", + "it ttttt", + "iti", + "iti tiii", + "iti ttti", + "itii", + "itii irr", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiit", + "itiiitii", + "itiiitit", + "itiiitrt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirtrr", + "itiirttt", + "itiit", + "itiit rr", + "itiit rt", + "itiititi", + "itiititt", + "itiitrrr", + "itiitrrt", + "itiitrtr", + "itiitt", + "itiittii", + "itiittit", + "itiittrr", + "itiittt", + "itiittti", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirrrtr", + "itirrrtt", + "itirrt", + "itirtrrr", + "itirtrt", + "itirtt", + "itirttrt", + "itirtttt", + "itit", + "ititi", + "ititiiii", + "ititiiit", + "ititiitt", + "ititirrt", + "ititirt", + "ititirtr", + "itititir", + "itititit", + "itititrr", + "itititt", + "itititti", + "ititittt", + "ititrrrr", + "ititrrti", + "ititrrtr", + "ititrrtt", + "ititrtit", + "ititrtrr", + "ititrtrt", + "ititt", + "itittiii", + "itittiit", + "itittit", + "itittiti", + "itittitt", + "itittrrt", + "itittrtr", + "itittti", + "ititttii", + "ititttit", + "ititttrr", + "ititttti", + "itittttr", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrt r", + "itrrrtrr", + "itrrrtrt", + "itrrrtt", + "itrrrttr", + "itrrrttt", + "itrrt", + "itrrt tt", + "itrrtiit", + "itrrtitt", + "itrrtrrr", + "itrrtrrt", + "itrrtrtr", + "itrrtrtt", + "itrrtti", + "itrrttii", + "itrrttit", + "itrrttrr", + "itrrttrt", + "itrrtttr", + "itrrtttt", + "itrt", + "itrt rr", + "itrt ttt", + "itrtiiir", + "itrtiirt", + "itrtirt", + "itrtirtt", + "itrtit", + "itrtitrt", + "itrtitti", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrtrr", + "itrtrtrt", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrtt t", + "itrttirr", + "itrttitt", + "itrttrrr", + "itrttrrt", + "itrttrtt", + "itrttt", + "itrtttit", + "itrtttrr", + "itrtttt", + "itrtttti", + "itrttttt", + "itt", + "itt t", + "itt ttt", + "itt t tt", + "itt ttt", + "itt tttr", + "itt tttt", + "itti", + "ittii", + "ittiiii", + "ittiiiii", + "ittiiiit", + "ittiiitr", + "ittiiitt", + "ittiit", + "ittiitii", + "ittiitrr", + "ittiitrt", + "ittiitti", + "ittiittt", + "ittirrrr", + "ittirrrt", + "ittirttr", + "ittirttt", + "ittit", + "ittiti", + "ittitiii", + "ittitiit", + "ittitirr", + "ittitirt", + "ittititi", + "ittititt", + "ittitrtt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittrr", + "ittittt", + "ittittti", + "ittitttr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrtrr", + "ittrrtrt", + "ittrrtti", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrt rr", + "ittrt tt", + "ittrti", + "ittrtitt", + "ittrtrrr", + "ittrtrrt", + "ittrtrtr", + "ittrtrtt", + "ittrtt", + "ittrttrr", + "ittrttrt", + "ittrttt", + "ittrttti", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt ttt", + "ittti", + "itttiii", + "itttiiii", + "itttiiit", + "itttiirr", + "itttiirt", + "itttiiti", + "itttiitt", + "itttirrt", + "itttirtt", + "itttit", + "itttiti", + "itttitii", + "itttitit", + "itttitt", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrtir", + "itttrtit", + "itttrtrr", + "itttrtrt", + "itttrtt", + "itttrtti", + "itttrttt", + "itttt", + "itttt it", + "itttti", + "ittttii", + "ittttiii", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt i", + "ittttt t", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "ritttttt", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt i", + "rrrrt ii", + "rrrrt ir", + "rrrrt it", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt ti", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt t", + "rrrt i", + "rrrt ii", + "rrrt it", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt ti", + "rrrt tr", + "rrrt tt", + "rrrt i", + "rrrt iii", + "rrrt iir", + "rrrt iit", + "rrrt irr", + "rrrt irt", + "rrrt itr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt tii", + "rrrt tir", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti i", + "rrrti rt", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtit r", + "rrrtiti", + "rrrtitii", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt i", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt t", + "rrrtt ii", + "rrrtt ir", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt ti", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt ii", + "rrt ir", + "rrt rr", + "rrt iir", + "rrt rrr", + "rrt rrt", + "rrt rtt", + "rrt t", + "rrt t t", + "rrt trr", + "rrt trt", + "rrt iiii", + "rrt irrr", + "rrt irt", + "rrt it", + "rrt itit", + "rrt itrr", + "rrt ittt", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rt t", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t rr", + "rrt t rt", + "rrt t tr", + "rrt tirr", + "rrt trrr", + "rrt trrt", + "rrt trt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt ttii", + "rrt ttrr", + "rrt ttrt", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti rrr", + "rrti ttr", + "rrtii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiit r", + "rrtiiti", + "rrtiitii", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiitti", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirti", + "rrtirtii", + "rrtirtir", + "rrtirtrr", + "rrtirtrt", + "rrtirtt", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtit rr", + "rrtitii", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtitirt", + "rrtitit", + "rrtititr", + "rrtititt", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtittii", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt t", + "rrtrt it", + "rrtrt rr", + "rrtrt rt", + "rrtrt t", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrti i", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtiti", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt t", + "rrtt rr", + "rrtt t", + "rrtt ti", + "rrtt iit", + "rrtt itt", + "rrtt rrr", + "rrtt rrt", + "rrtt rti", + "rrtt rtr", + "rrtt rtt", + "rrtt t", + "rrtt trr", + "rrtt trt", + "rrtt tt", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrtti i", + "rrttiii", + "rrttiiii", + "rrttiiit", + "rrttiirr", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit t", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt r", + "rrttt ii", + "rrttt ir", + "rrttt rr", + "rrttt rt", + "rrttt t", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt r", + "rt ii", + "rt ir", + "rt rr", + "rt tr", + "rt tt", + "rt iir", + "rt irr", + "rt rrr", + "rt rrt", + "rt ti", + "rt trr", + "rt tt", + "rt ttr", + "rt i", + "rt itrt", + "rt rrrr", + "rt rrrt", + "rt rrtr", + "rt rrtt", + "rt rt", + "rt rtrt", + "rt trrr", + "rt trtr", + "rt trtt", + "rt tt", + "rt tttr", + "rt i", + "rt i ii", + "rt iiiii", + "rt iirrr", + "rt iirti", + "rt iiti", + "rt iitii", + "rt iitrt", + "rt irrrt", + "rt irt", + "rt irtt", + "rt it", + "rt itirr", + "rt itrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtii", + "rt rrtrr", + "rt rrtrt", + "rt rrtti", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rt rr", + "rt rtrrr", + "rt rtrrt", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rttrr", + "rt rttti", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t r", + "rt t rr", + "rt t t", + "rt t ti", + "rt t rrr", + "rt t rrt", + "rt t t", + "rt t trr", + "rt t tti", + "rt ti", + "rt tiiir", + "rt tirrr", + "rt titrt", + "rt trrrr", + "rt trrrt", + "rt trrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trtrr", + "rt trtrt", + "rt trttr", + "rt trttt", + "rt tt", + "rt tt t", + "rt tt rt", + "rt tt tt", + "rt ttitt", + "rt ttrrr", + "rt ttrtr", + "rt ttrtt", + "rt ttt", + "rt tttii", + "rt tttrr", + "rt tttrt", + "rt tttt", + "rt tttti", + "rt ttttr", + "rt ttttt", + "rti", + "rti iiit", + "rtii", + "rtii it", + "rtii rr", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirtt", + "rtiiit", + "rtiiiti", + "rtiiitii", + "rtiiitit", + "rtiiitrr", + "rtiiitti", + "rtiiittr", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirrti", + "rtiirrtr", + "rtiirt", + "rtiirtrt", + "rtiirttt", + "rtiit", + "rtiit tt", + "rtiiti", + "rtiitiii", + "rtiitiit", + "rtiitirr", + "rtiitirt", + "rtiitrrt", + "rtiitrtr", + "rtiitrtt", + "rtiitt", + "rtiitti", + "rtiittii", + "rtiittrt", + "rtiittt", + "rtiittti", + "rtiitttr", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtir", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrtti", + "rtirt", + "rtirt rr", + "rtirt rt", + "rtirtiii", + "rtirtiir", + "rtirtirr", + "rtirtitt", + "rtirtrrr", + "rtirtrrt", + "rtirtrtt", + "rtirttii", + "rtirttrt", + "rtirtttt", + "rtit", + "rtit ti", + "rtit ttt", + "rtiti", + "rtitii", + "rtitiiir", + "rtitiiit", + "rtitiirt", + "rtitiit", + "rtitiiti", + "rtitiitr", + "rtitiitt", + "rtitirrr", + "rtitit", + "rtititir", + "rtititit", + "rtititrr", + "rtititti", + "rtitittr", + "rtitittt", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrti", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrti", + "rtitrtir", + "rtitrtit", + "rtitrtrt", + "rtitrttr", + "rtitrttt", + "rtitt", + "rtitti", + "rtittiii", + "rtittiit", + "rtittirr", + "rtittit", + "rtittrrr", + "rtittrrt", + "rtittrt", + "rtittrti", + "rtittrtt", + "rtittt", + "rtitttir", + "rtitttit", + "rtitttrr", + "rtitttrt", + "rtitttt", + "rtitttti", + "rtittttt", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt t", + "rtrrt ii", + "rtrrt ir", + "rtrrt it", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt ti", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt i", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt i", + "rtrt rr", + "rtrt rt", + "rtrt t", + "rtrt tr", + "rtrt tt", + "rtrt i", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rtr", + "rtrt rtt", + "rtrt t", + "rtrt trr", + "rtrt trt", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiirr", + "rtrtiirt", + "rtrtiitr", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtit r", + "rtrtitii", + "rtrtitit", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtittr", + "rtrtittt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt t", + "rtrtt rr", + "rtrtt rt", + "rtrtt t", + "rtrtt tr", + "rtrtt tt", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttiir", + "rtrttiit", + "rtrttirr", + "rtrttirt", + "rtrttit", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt r", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt rr", + "rtt tt", + "rtt ii", + "rtt irr", + "rtt itr", + "rtt t", + "rtt trt", + "rtt ttt", + "rtt iiir", + "rtt iit", + "rtt itrr", + "rtt rrrr", + "rtt rrrt", + "rtt rrt", + "rtt rrti", + "rtt rrtr", + "rtt rrtt", + "rtt rt", + "rtt rtrr", + "rtt rtrt", + "rtt rtt", + "rtt rttr", + "rtt rttt", + "rtt t", + "rtt t r", + "rtt tii", + "rtt tiii", + "rtt trrr", + "rtt trrt", + "rtt trt", + "rtt trtr", + "rtt trtt", + "rtt tt", + "rtt tt t", + "rtt ttrt", + "rtt ttt", + "rtt ttti", + "rtt tttt", + "rtti", + "rtti ii", + "rtti trr", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirti", + "rttiirtr", + "rttiirtt", + "rttiit", + "rttiit r", + "rttiitii", + "rttiitir", + "rttiitrr", + "rttiitt", + "rttiitti", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrt", + "rttirrti", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirttt", + "rttit", + "rttit t", + "rttit ti", + "rttiti", + "rttitiii", + "rttitirr", + "rttititi", + "rttititr", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrt", + "rttitrti", + "rttitrtr", + "rttitt", + "rttittii", + "rttittir", + "rttittit", + "rttittrr", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrtir", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt r", + "rttrt ii", + "rttrt rr", + "rttrt rt", + "rttrt t", + "rttrt tt", + "rttrti", + "rttrtii", + "rttrtiii", + "rttrtiir", + "rttrtiit", + "rttrtirr", + "rttrtirt", + "rttrtiti", + "rttrtitr", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt r", + "rttrtt t", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt t", + "rttt rr", + "rttt rt", + "rttt ti", + "rttt tr", + "rttt tt", + "rttt rrr", + "rttt rrt", + "rttt rt", + "rttt rtr", + "rttt rtt", + "rttt trr", + "rttt trt", + "rttt tt", + "rttt tti", + "rttt ttr", + "rttt ttt", + "rttti", + "rttti tt", + "rtttiii", + "rtttiiii", + "rtttiiir", + "rtttiirt", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirt", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttit r", + "rtttitii", + "rtttitir", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrt t", + "rtttrti", + "rtttrtii", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt i", + "rtttt r", + "rtttt t", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t i", + "t r", + "t t", + "t i", + "t ii", + "t rr", + "t rt", + "t t", + "t ti", + "t tr", + "t tt", + "t iit", + "t irr", + "t rrr", + "t rrt", + "t rtr", + "t rtt", + "t t", + "t trr", + "t trt", + "t tt", + "t tti", + "t ttt", + "t ittt", + "t rrrr", + "t rrtr", + "t rt r", + "t rtrr", + "t rtt", + "t t", + "t t r", + "t t t", + "t t rt", + "t trrr", + "t trrt", + "t ttii", + "t tttt", + "t i", + "t ii", + "t iiiii", + "t iiiir", + "t iiit", + "t iiiti", + "t iirrr", + "t iitii", + "t iitrt", + "t iittt", + "t irrrr", + "t irrtt", + "t it", + "t itit", + "t itrrr", + "t itt", + "t rrrrr", + "t rrrrt", + "t rrrtr", + "t rrrtt", + "t rrt", + "t rrti", + "t rrtii", + "t rrtrr", + "t rrtrt", + "t rrttr", + "t rt", + "t rt t", + "t rt rr", + "t rti", + "t rtii", + "t rtiii", + "t rtirt", + "t rtit", + "t rtrrr", + "t rtrrt", + "t rtrti", + "t rtrtr", + "t rtrtt", + "t rtt", + "t rtti", + "t rttrt", + "t rtttr", + "t rtttt", + "t t", + "t t rr", + "t t rt", + "t t t", + "t t i", + "t t rtr", + "t t t", + "t t t t", + "t t ttt", + "t tit", + "t trrrr", + "t trrrt", + "t trrtr", + "t trrtt", + "t trt", + "t trtrr", + "t trtt", + "t trttt", + "t tt", + "t tti", + "t ttiii", + "t ttrrr", + "t ttrrt", + "t ttrtr", + "t ttrtt", + "t ttt", + "t tttt", + "t ttttt", + "t i", + "t i rr", + "t iiiiii", + "t iiiiir", + "t iiiirr", + "t iit", + "t iitrrr", + "t iitrt", + "t irrrrr", + "t irrrtr", + "t irrtii", + "t irrtit", + "t irrtrt", + "t irt", + "t irtrtr", + "t it", + "t itiit", + "t itiiti", + "t itirrt", + "t itirtt", + "t itrrrr", + "t itrttt", + "t itt", + "t ittrti", + "t itttrr", + "t itttrt", + "t itttt", + "t itttti", + "t ittttt", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrt r", + "t rrrtir", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt rt", + "t rrtii", + "t rrtirr", + "t rrtiti", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrti", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrtt r", + "t rrtti", + "t rrttit", + "t rrttrr", + "t rrttrt", + "t rrttt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt r", + "t rt rr", + "t rt rtt", + "t rt t", + "t rti", + "t rtiiii", + "t rtirrr", + "t rtirtr", + "t rtitrr", + "t rtittt", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrrtr", + "t rtrrtt", + "t rtrt", + "t rtrtit", + "t rtrtrr", + "t rtrtrt", + "t rtrtt", + "t rtrttr", + "t rtrttt", + "t rtt", + "t rtt tt", + "t rtti", + "t rttiti", + "t rttrrr", + "t rttrrt", + "t rttrtr", + "t rttrtt", + "t rttt", + "t rtttrr", + "t rtttrt", + "t rtttt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t t t", + "t t rt", + "t t t", + "t t tr", + "t t rrr", + "t t rrt", + "t t rt", + "t t t", + "t t t r", + "t t trt", + "t t ttt", + "t t rrrt", + "t t rtrr", + "t t t t", + "t t trrr", + "t t tt", + "t t tti", + "t t ttrr", + "t t ttt", + "t ti", + "t tii", + "t tii rr", + "t tiii i", + "t tiiiii", + "t tirrrr", + "t tirrtt", + "t titt", + "t tittit", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrt t", + "t trrtir", + "t trrtrr", + "t trrtrt", + "t trrtt", + "t trrttr", + "t trrttt", + "t trt", + "t trt rt", + "t trti t", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrti", + "t trtrtr", + "t trtrtt", + "t trtt", + "t trttrr", + "t trttrt", + "t trttt", + "t trtttr", + "t trtttt", + "t tt", + "t tt r", + "t tt rr", + "t tt tt", + "t tt rrr", + "t tt rtr", + "t tt rtt", + "t tt t t", + "t tt ttr", + "t tt ttt", + "t tti", + "t ttiiii", + "t ttirrt", + "t ttitii", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrt", + "t ttrrtr", + "t ttrrtt", + "t ttrt", + "t ttrtrr", + "t ttrtrt", + "t ttrttr", + "t ttrttt", + "t ttt", + "t ttt r", + "t ttt t", + "t ttt tt", + "t tttii", + "t tttiit", + "t tttirt", + "t tttitt", + "t tttrrr", + "t tttrrt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttti", + "t ttttii", + "t ttttit", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti rrt", + "ti itii", + "ti i", + "ti iiiii", + "ti iiiir", + "ti rtrtt", + "ti t", + "ti t tti", + "ti tit", + "ti ttiit", + "ti ttitr", + "tii", + "tii i ii", + "tii rrrr", + "tii ttrr", + "tii tttt", + "tiii", + "tiii tr", + "tiii tt", + "tiii ttt", + "tiiii", + "tiiii ii", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirtt", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtt", + "tiiirtrr", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitirr", + "tiiitit", + "tiiititi", + "tiiititr", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiitt t", + "tiiittii", + "tiiittir", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrrtt", + "tiirrtii", + "tiirrtit", + "tiirrtrr", + "tiirrttt", + "tiirt", + "tiirt t", + "tiirtirt", + "tiirtrrr", + "tiirtrrt", + "tiirtrt", + "tiirtrti", + "tiirtt", + "tiirttii", + "tiirttrt", + "tiirttti", + "tiirtttt", + "tiit", + "tiit tr", + "tiit itt", + "tiit rrr", + "tiiti", + "tiiti tt", + "tiitii", + "tiitii t", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiiti", + "tiitiitt", + "tiitirrr", + "tiitirrt", + "tiitirti", + "tiitit", + "tiitit t", + "tiititii", + "tiititit", + "tiititt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrti", + "tiitrtii", + "tiitrtit", + "tiitrtrt", + "tiitrtt", + "tiitrttr", + "tiitrttt", + "tiitt", + "tiitt it", + "tiitt tt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiit", + "tiittirt", + "tiittit", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrtr", + "tiittrtt", + "tiittt", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtit", + "tirrrtrr", + "tirrrtrt", + "tirrrtti", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrt tr", + "tirrti", + "tirrtii", + "tirrtit", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrt", + "tirrtrtt", + "tirrtt", + "tirrttrr", + "tirrttt", + "tirrttti", + "tirrtttr", + "tirrtttt", + "tirt", + "tirt i", + "tirti", + "tirtiii", + "tirtiiii", + "tirtirrt", + "tirtitir", + "tirtitt", + "tirtrrrr", + "tirtrrrt", + "tirtrrti", + "tirtrrtr", + "tirtrrtt", + "tirtrti", + "tirtrtrt", + "tirtrtt", + "tirtrttr", + "tirtrttt", + "tirtt", + "tirtti t", + "tirttiii", + "tirttiir", + "tirttirr", + "tirttirt", + "tirttrrr", + "tirttrrt", + "tirttrt", + "tirttrtr", + "tirttrtt", + "tirttt", + "tirtttir", + "tirtttrr", + "tirtttrt", + "tirtttt", + "tirttttr", + "tirttttt", + "tit", + "tit iitt", + "tit rt", + "tit rttt", + "tit t", + "titi", + "titi it", + "titii", + "titiii", + "titiiiii", + "titiiiit", + "titiiit", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirtr", + "titiit", + "titiitii", + "titiitir", + "titiitit", + "titiitrr", + "titiitrt", + "titiitt", + "titiitti", + "titiittr", + "titiittt", + "titirrrr", + "titirrrt", + "titirrtr", + "titirt", + "titirtrr", + "titit", + "titit tt", + "tititi", + "tititiii", + "tititiit", + "tititirr", + "tititirt", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititrti", + "tititrtt", + "tititt", + "tititt t", + "titittii", + "titittir", + "titittit", + "titittrr", + "titittt", + "titittti", + "tititttr", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrtii", + "titrrtir", + "titrrtrr", + "titrrtrt", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrtiii", + "titrtirr", + "titrtrrr", + "titrtrrt", + "titrtrti", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrtti", + "titrttii", + "titrttrr", + "titrttrt", + "titrttti", + "titrtttr", + "titrtttt", + "titt", + "titt itr", + "titt itt", + "titti", + "tittii", + "tittiii", + "tittiiii", + "tittiiir", + "tittiiit", + "tittiirr", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirrr", + "tittirrt", + "tittirt", + "tittit", + "tittiti", + "tittitii", + "tittitit", + "tittitrt", + "tittitt", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrtr", + "tittrrtt", + "tittrtit", + "tittrtrr", + "tittrtrt", + "tittrtt", + "tittrtti", + "tittrttr", + "tittrttt", + "tittt", + "tittt tt", + "tittti", + "titttii", + "titttiii", + "titttiir", + "titttiit", + "titttirr", + "titttiti", + "titttitr", + "titttitt", + "titttrrr", + "titttrrt", + "titttrt", + "titttrti", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt t", + "trrrt i", + "trrrt rr", + "trrrt rt", + "trrrt t", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiit", + "trrrtirr", + "trrrtit", + "trrrtiti", + "trrrtitr", + "trrrtitt", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt t", + "trrt rr", + "trrt t", + "trrt tr", + "trrt i", + "trrt iir", + "trrt irr", + "trrt itr", + "trrt rrr", + "trrt rrt", + "trrt rt", + "trrt rtr", + "trrt rtt", + "trrt t", + "trrt t r", + "trrt t t", + "trrt trr", + "trrt trt", + "trrt tt", + "trrt ttr", + "trrt ttt", + "trrti", + "trrtii", + "trrtiii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirr", + "trrtiirt", + "trrtiitr", + "trrtiitt", + "trrtirrr", + "trrtirtr", + "trrtirtt", + "trrtit", + "trrtiti", + "trrtitii", + "trrtitir", + "trrtitrr", + "trrtitrt", + "trrtitt", + "trrtittr", + "trrtittt", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrt t", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt t", + "trrtt it", + "trrtt rr", + "trrtt t", + "trrtt ti", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrttii", + "trrttiii", + "trrttiir", + "trrttiit", + "trrttirr", + "trrttirt", + "trrttiti", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt t", + "trrttti", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt ii", + "trt rr", + "trt tr", + "trt itr", + "trt rrr", + "trt rrt", + "trt rt", + "trt rtt", + "trt t", + "trt trr", + "trt ttt", + "trt it", + "trt rrrr", + "trt rrrt", + "trt rrt", + "trt rrtr", + "trt rrtt", + "trt rtit", + "trt rtrr", + "trt rtrt", + "trt rttr", + "trt rttt", + "trt t", + "trt t rr", + "trt trrr", + "trt trrt", + "trt trti", + "trt trtr", + "trt trtt", + "trt ttir", + "trt ttrr", + "trt ttrt", + "trt ttt", + "trt tttr", + "trt tttt", + "trti", + "trtii", + "trtiiii", + "trtiiiii", + "trtiiit", + "trtiirrr", + "trtiit", + "trtiit t", + "trtiiti", + "trtiitit", + "trtiitrr", + "trtiitrt", + "trtiittr", + "trtiittt", + "trtirrrr", + "trtirrrt", + "trtirrti", + "trtirrtr", + "trtirt", + "trtirtit", + "trtirtrr", + "trtirtrt", + "trtirtt", + "trtirtti", + "trtirttr", + "trtirttt", + "trtit", + "trtitirt", + "trtitit", + "trtitrrr", + "trtitrrt", + "trtitrt", + "trtitrti", + "trtitrtr", + "trtitrtt", + "trtitt", + "trtittit", + "trtittrr", + "trtittrt", + "trtitttt", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrti", + "trtrrtii", + "trtrrtir", + "trtrrtit", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt t", + "trtrt rr", + "trtrt rt", + "trtrt t", + "trtrt tr", + "trtrt tt", + "trtrti", + "trtrtii", + "trtrtiii", + "trtrtiir", + "trtrtiit", + "trtrtirr", + "trtrtit", + "trtrtitr", + "trtrtitt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtt t", + "trtrtti", + "trtrttii", + "trtrttir", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt t", + "trtt ii", + "trtt rr", + "trtt t", + "trtt tr", + "trtt tt", + "trtt iit", + "trtt irt", + "trtt rrr", + "trtt rrt", + "trtt rt", + "trtt rti", + "trtt rtr", + "trtt rtt", + "trtt t", + "trtt t t", + "trtt tii", + "trtt tit", + "trtt trr", + "trtt trt", + "trtt tti", + "trtt ttr", + "trtt ttt", + "trtti", + "trttii", + "trttiii", + "trttiiii", + "trttiiir", + "trttiiit", + "trttiirr", + "trttiit", + "trttiiti", + "trttiitr", + "trttirrr", + "trttirt", + "trttirtt", + "trttit", + "trttitrr", + "trttitrt", + "trttitt", + "trttitti", + "trttittr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt r", + "trttrt t", + "trttrti", + "trttrtii", + "trttrtit", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt ii", + "trttt rr", + "trttt rt", + "trttt tr", + "trttt tt", + "trttti", + "trtttiii", + "trtttiit", + "trtttirr", + "trtttit", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt i", + "trtttt r", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt r", + "tt t", + "tt ii", + "tt rr", + "tt rt", + "tt t", + "tt tr", + "tt tt", + "tt i r", + "tt iii", + "tt iir", + "tt itr", + "tt itt", + "tt rrr", + "tt rtt", + "tt t", + "tt trr", + "tt trt", + "tt tt", + "tt tti", + "tt ttt", + "tt ii", + "tt irrt", + "tt rrrr", + "tt rrrt", + "tt rrtr", + "tt rt", + "tt rtrr", + "tt rtrt", + "tt t", + "tt t r", + "tt t t", + "tt t tr", + "tt t tt", + "tt trrt", + "tt trt", + "tt trtt", + "tt tt", + "tt ttii", + "tt ttrr", + "tt ttt", + "tt tttt", + "tt i", + "tt i ti", + "tt iiiii", + "tt iirrr", + "tt iirrt", + "tt iirti", + "tt iirtr", + "tt iiti", + "tt iitrr", + "tt irrrr", + "tt irrtt", + "tt irtrt", + "tt it", + "tt itrrr", + "tt itrt", + "tt itttt", + "tt rrrrr", + "tt rrrrt", + "tt rrrt", + "tt rrrti", + "tt rrt", + "tt rrt r", + "tt rrt t", + "tt rrtrr", + "tt rrtrt", + "tt rrttr", + "tt rrttt", + "tt rt", + "tt rt rr", + "tt rtrrr", + "tt rtrrt", + "tt rtrtr", + "tt rtrtt", + "tt rtt", + "tt rttrr", + "tt rtttt", + "tt t", + "tt t t", + "tt t ti", + "tt t rrr", + "tt t trr", + "tt t trt", + "tt t tt", + "tt t ttt", + "tt ti", + "tt tiiii", + "tt titrr", + "tt trrrr", + "tt trrrt", + "tt trrt", + "tt trrtr", + "tt trrtt", + "tt trt", + "tt trtrr", + "tt trtrt", + "tt trtt", + "tt trttr", + "tt trttt", + "tt tt", + "tt tt t", + "tt tti", + "tt ttitt", + "tt ttrrr", + "tt ttrrt", + "tt ttrt", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt ttt t", + "tt ttti", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti tt", + "tti tttt", + "ttii", + "ttii iii", + "ttii iti", + "ttii tir", + "ttii trr", + "ttiii", + "ttiii ii", + "ttiii tt", + "ttiiii", + "ttiiii i", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirt", + "ttiiirti", + "ttiiirtr", + "ttiiirtt", + "ttiiit", + "ttiiiti", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrt", + "ttiirrti", + "ttiirrtr", + "ttiirrtt", + "ttiirt", + "ttiirtit", + "ttiirtrr", + "ttiirtrt", + "ttiirttr", + "ttiirttt", + "ttiit", + "ttiit ii", + "ttiit tr", + "ttiiti", + "ttiitiii", + "ttiitiit", + "ttiitit", + "ttiititi", + "ttiititr", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrti", + "ttirrrtr", + "ttirrrtt", + "ttirrt t", + "ttirrti", + "ttirrtii", + "ttirrtir", + "ttirrtrt", + "ttirrtt", + "ttirrtti", + "ttirrttr", + "ttirrttt", + "ttirt", + "ttirt t", + "ttirti", + "ttirtiit", + "ttirtrrr", + "ttirtrrt", + "ttirtrti", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttii", + "ttirttir", + "ttirttit", + "ttirttrr", + "ttirttrt", + "ttirttt", + "ttirttti", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit i", + "ttit itr", + "ttit rrr", + "ttit ttt", + "ttiti", + "ttitii", + "ttitii i", + "ttitiii", + "ttitiiii", + "ttitiiir", + "ttitiiit", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirrr", + "ttitit", + "ttititi", + "ttititii", + "ttititit", + "ttititt", + "ttititti", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrtr", + "ttitrrtt", + "ttitrtit", + "ttitrtrr", + "ttitrtrt", + "ttitrtt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt t", + "ttitt rr", + "ttitt ti", + "ttitt tt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrt", + "ttittrti", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt r", + "ttittti", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt t", + "ttrrt rr", + "ttrrt rt", + "ttrrt t", + "ttrrt tr", + "ttrrt tt", + "ttrrti", + "ttrrtiii", + "ttrrtiit", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtitr", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrtt t", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt t", + "ttrt rr", + "ttrt rt", + "ttrt tr", + "ttrt rrr", + "ttrt rrt", + "ttrt rt", + "ttrt rtr", + "ttrt rtt", + "ttrt t", + "ttrt tir", + "ttrt trr", + "ttrt trt", + "ttrt tti", + "ttrt ttr", + "ttrt ttt", + "ttrti", + "ttrtii", + "ttrtiiii", + "ttrtiirt", + "ttrtiit", + "ttrtiitt", + "ttrtirrr", + "ttrtirrt", + "ttrtirt", + "ttrtirtr", + "ttrtirtt", + "ttrtit r", + "ttrtitii", + "ttrtitrt", + "ttrtitt", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrt t", + "ttrtrti", + "ttrtrtii", + "ttrtrtit", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt ii", + "ttrtt rr", + "ttrtt rt", + "ttrtt t", + "ttrtt tr", + "ttrtt tt", + "ttrtti", + "ttrttiii", + "ttrttiir", + "ttrttiit", + "ttrttirr", + "ttrttirt", + "ttrttiti", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrttti", + "ttrtttii", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt r", + "ttt t", + "ttt ii", + "ttt rr", + "ttt rt", + "ttt tr", + "ttt tt", + "ttt rrr", + "ttt rrt", + "ttt rtt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt tit", + "ttt trr", + "ttt trt", + "ttt tti", + "ttt ttt", + "ttt ii", + "ttt itrt", + "ttt rrrr", + "ttt rrrt", + "ttt rrt", + "ttt rrti", + "ttt rrtr", + "ttt rrtt", + "ttt rtit", + "ttt rtrr", + "ttt rtrt", + "ttt rttr", + "ttt rttt", + "ttt t", + "ttt t r", + "ttt t t", + "ttt t rr", + "ttt t tr", + "ttt t tt", + "ttt ti", + "ttt tiii", + "ttt titt", + "ttt trrr", + "ttt trrt", + "ttt trt", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt tt t", + "ttt ttit", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti ii", + "ttti rr", + "ttti i", + "ttti itt", + "ttti rrr", + "ttti t", + "ttti trt", + "ttti ttr", + "tttii", + "tttii t", + "tttiii", + "tttiii i", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirt", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitir", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrtr", + "tttirrtt", + "tttirtit", + "tttirtrr", + "tttirtrt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit rt", + "tttiti", + "tttiti t", + "tttitii", + "tttitiii", + "tttitiir", + "tttitiit", + "tttitirr", + "tttitirt", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitt t", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrt t", + "tttrrti", + "tttrrtii", + "tttrrtir", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt t", + "tttrt ir", + "tttrt rr", + "tttrt rt", + "tttrt t", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrtiii", + "tttrtiir", + "tttrtiit", + "tttrtirr", + "tttrtirt", + "tttrtit", + "tttrtitr", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt i", + "tttrtt r", + "tttrtt t", + "tttrtti", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt i", + "tttt r", + "tttt t", + "tttt i", + "tttt ii", + "tttt ir", + "tttt it", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt iii", + "tttt rrr", + "tttt rrt", + "tttt rt", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt tir", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti t", + "tttti ii", + "tttti rt", + "tttti t", + "tttti tt", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirti", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttit i", + "ttttit r", + "ttttit t", + "ttttiti", + "ttttitii", + "ttttitir", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtii", + "ttttrtir", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt ii", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti i", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrit", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr18": [ + "-1", + "-2", + "-6", + "i", + "i ii", + "i rr", + "i tti", + "i tttt", + "i iiiii", + "i it", + "i t", + "i ttttt", + "i i", + "i ii", + "i iii", + "i iiii", + "i iiiii", + "i iiiiii", + "i iiiirr", + "i iiitii", + "i iiittt", + "i iirrrr", + "i irrtrt", + "i it", + "i ittrrt", + "i itttit", + "i ittttt", + "i rrrrrr", + "i rtrrr", + "i rttttt", + "i t", + "i t trrr", + "i tiiiit", + "i tittt", + "i trrrrr", + "i trtt", + "i tt", + "i ttiiii", + "i ttiiit", + "i tttttt", + "ii", + "ii i", + "ii r", + "ii t", + "ii ii", + "ii ii ii", + "ii iii", + "ii iiii", + "ii iiiii", + "ii iittt", + "ii itiit", + "ii rrrtt", + "ii t", + "ii ti", + "ii tiitt", + "ii trrrt", + "ii ttrrr", + "ii tttti", + "ii ttttt", + "iii", + "iii tt", + "iii ttt", + "iii iiii", + "iii iiit", + "iii ittt", + "iii tt", + "iiii", + "iiii ii", + "iiii iii", + "iiii tii", + "iiii ttt", + "iiiii", + "iiiii t", + "iiiii i", + "iiiii ii", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiir", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiit t", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirti", + "iiiirtii", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirtti", + "iiiirttt", + "iiiit", + "iiiit tt", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiititi", + "iiiititr", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrti", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiir", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtit", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrttt", + "iiirt", + "iiirti", + "iiirtiii", + "iiirtiir", + "iiirtiti", + "iiirtrrr", + "iiirtrrt", + "iiirtrtr", + "iiirtrtt", + "iiirtt", + "iiirttrt", + "iiirttt", + "iiirtttt", + "iiit", + "iiit t", + "iiit i", + "iiiti", + "iiitii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitirrr", + "iiitirt", + "iiitirti", + "iiitirtr", + "iiitit", + "iiititi", + "iiititii", + "iiititit", + "iiititrt", + "iiititt", + "iiititti", + "iiitittt", + "iiitrrr", + "iiitrrrr", + "iiitrrrt", + "iiitrrti", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrtii", + "iiitrtrr", + "iiitrtrt", + "iiitrtti", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitt i", + "iiitt tt", + "iiitti", + "iiittii", + "iiittiii", + "iiittiit", + "iiittirt", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrti", + "iiittrtt", + "iiittt", + "iiittt t", + "iiittti", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttt", + "iir", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtii", + "iirrrtir", + "iirrrtit", + "iirrrtrr", + "iirrrtrt", + "iirrrtt", + "iirrrttr", + "iirrt", + "iirrt rr", + "iirrtiii", + "iirrtiit", + "iirrtiti", + "iirrtrrr", + "iirrtrrt", + "iirrtrt", + "iirrtrtr", + "iirrtrtt", + "iirrtt", + "iirrttir", + "iirrttrr", + "iirrttrt", + "iirrttt", + "iirrtttt", + "iirt", + "iirti", + "iirtiiii", + "iirtiiit", + "iirtiit", + "iirtirrt", + "iirtiti", + "iirtitti", + "iirtrrrr", + "iirtrrrt", + "iirtrrt", + "iirtrrtt", + "iirtrt", + "iirtrtii", + "iirtrtrt", + "iirtrtt", + "iirttiii", + "iirttiit", + "iirttitt", + "iirttrrr", + "iirttrrt", + "iirttrtr", + "iirttrtt", + "iirttt", + "iirttti", + "iirtttt", + "iirttttt", + "iit", + "iit ttrt", + "iiti", + "iiti ttt", + "iitii", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiir", + "iitiiiit", + "iitiiit", + "iitiiiti", + "iitiiitt", + "iitiirrr", + "iitiirrt", + "iitiit", + "iitiitii", + "iitiitit", + "iitiitti", + "iitiittr", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitirrtt", + "iitirtti", + "iitirttt", + "iitit", + "iititi", + "iititii", + "iititiii", + "iititiit", + "iititit", + "iitititi", + "iititrtr", + "iititt", + "iititti", + "iitittii", + "iitittit", + "iitittrr", + "iitittt", + "iitittti", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrtr", + "iitrrrtt", + "iitrrtrr", + "iitrrtrt", + "iitrrttr", + "iitrrttt", + "iitrt", + "iitrtii", + "iitrtiii", + "iitrtrrr", + "iitrtrrt", + "iitrtrt", + "iitrtrtr", + "iitrttrr", + "iitrttrt", + "iitrttt", + "iitrtttr", + "iitrtttt", + "iitt", + "iitti", + "iittii", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiiti", + "iittiitt", + "iittirrr", + "iittirtt", + "iittitii", + "iittitit", + "iittitti", + "iittittr", + "iittittt", + "iittrrrr", + "iittrrtr", + "iittrrtt", + "iittrtii", + "iittrtrr", + "iittrtrt", + "iittrtt", + "iittrtti", + "iittrttr", + "iittrttt", + "iittt", + "iittt tt", + "iittti", + "iitttii", + "iitttiii", + "iitttiit", + "iitttirt", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irirrrrr", + "irr", + "irrr", + "irrrr", + "irrrrr", + "irrrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrtir", + "irrrrtit", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrtti", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrti", + "irrrtiii", + "irrrtit", + "irrrtr", + "irrrtrrr", + "irrrtrrt", + "irrrtrti", + "irrrtrtr", + "irrrtrtt", + "irrrtt", + "irrrtti", + "irrrttit", + "irrrttrr", + "irrrttrt", + "irrrttti", + "irrrtttr", + "irrt", + "irrti", + "irrtii", + "irrtiiii", + "irrtiitr", + "irrtirrr", + "irrtitrr", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrti", + "irrtrrtt", + "irrtrt r", + "irrtrtii", + "irrtrtrr", + "irrtrtrt", + "irrtrtti", + "irrtrttt", + "irrtt", + "irrttirt", + "irrttrrt", + "irrttrtr", + "irrttrtt", + "irrttt", + "irrtttii", + "irrtttrr", + "irrttttt", + "irt", + "irt r", + "irt rrrr", + "irti", + "irtiiiii", + "irtiiitt", + "irtiitii", + "irtirrti", + "irtitit", + "irtitrrr", + "irtittit", + "irtittti", + "irtrrrrr", + "irtrrrrt", + "irtrrrtt", + "irtrrtrr", + "irtrrtt", + "irtrrttt", + "irtrt", + "irtrt t", + "irtrti", + "irtrtiii", + "irtrtirr", + "irtrtiti", + "irtrtr", + "irtrtrrr", + "irtrtrrt", + "irtrtrtr", + "irtrtt", + "irtt", + "irtti", + "irttiiit", + "irttiirr", + "irttirrr", + "irttirt", + "irttit", + "irttittt", + "irttrrrr", + "irttrrtt", + "irttrtt", + "irttrtti", + "irttrttr", + "irttrttt", + "irttt", + "irtttiii", + "irtttitt", + "irtttrtr", + "irtttrtt", + "irtttt", + "irttttii", + "irttttt", + "irttttti", + "irtttttr", + "irtttttt", + "it", + "it i", + "it tttt", + "it iirrt", + "it titrr", + "it tt", + "it tttti", + "iti", + "itii", + "itiii", + "itiiiiii", + "itiiiiit", + "itiiiirr", + "itiiiirt", + "itiiiit", + "itiiiiti", + "itiiiitt", + "itiiit", + "itiiiti", + "itiiitii", + "itiiitit", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirrrt", + "itiirrti", + "itiirrtt", + "itiirtir", + "itiirtrr", + "itiirttt", + "itiit", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiitrrr", + "itiitrt", + "itiitrtt", + "itiitt", + "itiittii", + "itiittir", + "itiittit", + "itiittrt", + "itiittt", + "itiittti", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrtt", + "itirrt", + "itirrtrr", + "itirt", + "itirtrti", + "itirtttt", + "itit", + "ititi", + "ititii", + "ititiiii", + "ititiiit", + "ititiiti", + "ititiitr", + "ititiitt", + "ititirrr", + "ititit", + "itititii", + "itititit", + "itititrr", + "itititrt", + "itititt", + "ititittt", + "ititrrrr", + "ititrrrt", + "ititrrtt", + "ititrti", + "ititrttt", + "ititt", + "ititti", + "itittiii", + "itittiit", + "itittiti", + "itittitt", + "itittrrr", + "itittt", + "ititttii", + "ititttit", + "ititttt", + "ititttti", + "itittttt", + "itrrrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrtir", + "itrrrtit", + "itrrrtrr", + "itrrrtrt", + "itrrrtt", + "itrrrtti", + "itrrrttt", + "itrrt", + "itrrtiii", + "itrrtiir", + "itrrtiti", + "itrrtrrr", + "itrrtrrt", + "itrrtrti", + "itrrtrtr", + "itrrtrtt", + "itrrtt", + "itrrttrr", + "itrrttrt", + "itrrtttt", + "itrt", + "itrti", + "itrtiiii", + "itrtiirr", + "itrtiit", + "itrtirtr", + "itrtit", + "itrtiti", + "itrtitir", + "itrtitit", + "itrtrrrr", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrt", + "itrtrtit", + "itrtrtrr", + "itrtrtrt", + "itrtrttt", + "itrtt", + "itrtti", + "itrttrrr", + "itrttrrt", + "itrttrtr", + "itrttrtt", + "itrtttir", + "itrtttrt", + "itrtttt", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt ttt", + "itti", + "ittii", + "ittiii", + "ittiiii", + "ittiiiii", + "ittiiiir", + "ittiiiit", + "ittiiirr", + "ittiiitr", + "ittiiitt", + "ittiit", + "ittiitit", + "ittiitrr", + "ittiitt", + "ittiitti", + "ittiittr", + "ittiittt", + "ittirrrr", + "ittit", + "ittitiii", + "ittititi", + "ittititt", + "ittitrrr", + "ittitrtt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittrt", + "ittittt", + "ittittti", + "ittitttr", + "ittitttt", + "ittrr", + "ittrrrrr", + "ittrrrrt", + "ittrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrtrr", + "ittrrtrt", + "ittrrtt", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrtiii", + "ittrtr", + "ittrtrrr", + "ittrtrrt", + "ittrtrtr", + "ittrtrtt", + "ittrttrr", + "ittrttti", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt tt", + "ittt ttt", + "ittti", + "itttiiii", + "itttiiit", + "itttiiti", + "itttiitt", + "itttirrr", + "itttirrt", + "itttirtr", + "itttirtt", + "itttit", + "itttiti", + "itttitii", + "itttitit", + "itttitrt", + "itttitt", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrtii", + "itttrtir", + "itttrtrr", + "itttrtrt", + "itttrttr", + "itttrttt", + "itttt", + "itttt ti", + "itttt tt", + "itttti", + "ittttii", + "ittttiii", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt i", + "ittttt t", + "ittttti", + "itttttii", + "itttttit", + "itttttr", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rirrrrrr", + "ritrrrti", + "rr", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt it", + "rrrrt r", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt t", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt tr", + "rrrt tt", + "rrrt r", + "rrrt rr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t r", + "rrrt t t", + "rrrt tii", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt tti", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt t", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrr", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttr", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt t", + "rrt tt", + "rrt rrr", + "rrt rrt", + "rrt rtr", + "rrt rtt", + "rrt t", + "rrt t r", + "rrt trr", + "rrt ttt", + "rrt rrr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrti", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rti", + "rrt rtit", + "rrt rtrr", + "rrt rtt", + "rrt rtti", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t r", + "rrt t rt", + "rrt t tr", + "rrt tiii", + "rrt trrr", + "rrt trrt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt ttrr", + "rrt ttrt", + "rrt ttt", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti rt", + "rrtii", + "rrtii rt", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiir", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirr", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiitii", + "rrtiitir", + "rrtiitrr", + "rrtiitrt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirti", + "rrtirtii", + "rrtirtrr", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtitit", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtittii", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtr", + "rrtrr", + "rrtrrr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt rr", + "rrtrt rt", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtitr", + "rrtrtitt", + "rrtrtr", + "rrtrtrr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttr", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt rr", + "rrtt t", + "rrtt tr", + "rrtt rrr", + "rrtt rrt", + "rrtt rtt", + "rrtt trr", + "rrtt trt", + "rrtt ttt", + "rrtti", + "rrtti rr", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitt", + "rrttittr", + "rrttittt", + "rrttrr", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt rr", + "rrttt rt", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrr", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt i", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttr", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt i", + "rt r", + "rt t", + "rt rt", + "rt rr", + "rt rrr", + "rt t", + "rt trr", + "rt trt", + "rt tt", + "rt ttr", + "rt rrr", + "rt rrrr", + "rt rrrt", + "rt rrt", + "rt rrtt", + "rt t", + "rt t r", + "rt t t", + "rt trrr", + "rt trrt", + "rt trtr", + "rt trtt", + "rt tt", + "rt ttrr", + "rt ttt", + "rt tttt", + "rt iittt", + "rt irrrt", + "rt it it", + "rt ittrr", + "rt r", + "rt rrr", + "rt rrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrttr", + "rt rt", + "rt rt rt", + "rt rti", + "rt rtiii", + "rt rtirt", + "rt rtitt", + "rt rtrrr", + "rt rtrrt", + "rt rtrt", + "rt rtrtr", + "rt rtt", + "rt rtttt", + "rt t", + "rt t rtr", + "rt t tt", + "rt ti rt", + "rt tiiii", + "rt tiiir", + "rt trrrr", + "rt trrrt", + "rt trrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trtrr", + "rt trtrt", + "rt trtt", + "rt trttt", + "rt tt", + "rt ttiit", + "rt ttrrr", + "rt ttrrt", + "rt ttrtr", + "rt ttt", + "rt tttii", + "rt tttrt", + "rt tttt", + "rt tttti", + "rt ttttt", + "rti", + "rti tt", + "rtii", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirt", + "rtiiirtr", + "rtiiirtt", + "rtiiit", + "rtiiitii", + "rtiiitrr", + "rtiiitt", + "rtiiitti", + "rtiiittt", + "rtiirrr", + "rtiirrrr", + "rtiirrrt", + "rtiirrti", + "rtiirrtr", + "rtiirtii", + "rtiirtrr", + "rtiirtti", + "rtiirttr", + "rtiirttt", + "rtiit", + "rtiiti", + "rtiitii", + "rtiitiit", + "rtiititi", + "rtiititt", + "rtiitrrr", + "rtiitrrt", + "rtiitrtr", + "rtiitrtt", + "rtiitt", + "rtiitti", + "rtiittii", + "rtiittit", + "rtiittrt", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtii", + "rtirrtir", + "rtirrtit", + "rtirrtr", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrtti", + "rtirrttt", + "rtirt", + "rtirtii", + "rtirtirt", + "rtirtrrr", + "rtirtrt", + "rtirtrtr", + "rtirtrtt", + "rtirtt", + "rtirttrt", + "rtirttti", + "rtirtttr", + "rtirtttt", + "rtit", + "rtiti", + "rtitii", + "rtitiiii", + "rtitiiit", + "rtitiirt", + "rtitiiti", + "rtitiitt", + "rtitirrr", + "rtitirti", + "rtitirtt", + "rtitit", + "rtitittt", + "rtitrrr", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrtt", + "rtitrtii", + "rtitrtrt", + "rtitrtti", + "rtitrttr", + "rtitrttt", + "rtitt", + "rtitti", + "rtittiii", + "rtittirr", + "rtittitr", + "rtittitt", + "rtittrrr", + "rtittrti", + "rtittrtt", + "rtittt", + "rtittti", + "rtitttii", + "rtitttir", + "rtitttrr", + "rtitttrt", + "rtitttti", + "rtittttt", + "rtr", + "rtrr", + "rtrrr", + "rtrrrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrti", + "rtrrti t", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitr", + "rtrrtitt", + "rtrrtr", + "rtrrtrr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt i", + "rtrt rr", + "rtrt rt", + "rtrt t", + "rtrt tr", + "rtrt tt", + "rtrt rrt", + "rtrt rtr", + "rtrt t", + "rtrt tr", + "rtrt trr", + "rtrt trt", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiirr", + "rtrtiit", + "rtrtiiti", + "rtrtiitr", + "rtrtiitt", + "rtrtirr", + "rtrtirrr", + "rtrtirrt", + "rtrtirti", + "rtrtirtr", + "rtrtit", + "rtrtit i", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtitti", + "rtrtittr", + "rtrtittt", + "rtrtrr", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtii", + "rtrtrtit", + "rtrtrtr", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt r", + "rtrtt t", + "rtrtt rt", + "rtrtt tr", + "rtrtt tt", + "rtrtti", + "rtrttiii", + "rtrttit", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttr", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt r", + "rtt t", + "rtt rrr", + "rtt rt", + "rtt trr", + "rtt trt", + "rtt i", + "rtt rrrr", + "rtt rrrt", + "rtt rrt", + "rtt rtr", + "rtt rttr", + "rtt t", + "rtt trrr", + "rtt trrt", + "rtt trtr", + "rtt trtt", + "rtt tt", + "rtt ttii", + "rtt ttrr", + "rtt ttt", + "rtt tttr", + "rtt tttt", + "rtti", + "rttii", + "rttiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiit", + "rttiitii", + "rttiitit", + "rttiitrr", + "rttiitrt", + "rttiitti", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtii", + "rttirtit", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirtti", + "rttirttt", + "rttit", + "rttiti", + "rttitiii", + "rttitiir", + "rttitiit", + "rttitirr", + "rttitirt", + "rttititi", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrtt", + "rttitt", + "rttittit", + "rttittrr", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrti", + "rttrrtii", + "rttrrtir", + "rttrrtit", + "rttrrtr", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt r", + "rttrt rr", + "rttrt rt", + "rttrt tt", + "rttrti", + "rttrtii", + "rttrtiii", + "rttrtirr", + "rttrtirt", + "rttrtit", + "rttrtitt", + "rttrtrr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt t", + "rttrtti", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt rr", + "rttt rt", + "rttt i", + "rttt rrt", + "rttt t", + "rttt t t", + "rttt trr", + "rttt tt", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttii", + "rtttiiii", + "rtttiiit", + "rtttiit", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrr", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrti", + "rtttrtii", + "rtttrtir", + "rtttrtit", + "rtttrtr", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt rr", + "rtttt t", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttr", + "rttttrr", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t i", + "t r", + "t rr", + "t rt", + "t t", + "t tr", + "t tt", + "t rrr", + "t rrt", + "t rt", + "t t r", + "t trr", + "t trt", + "t tt", + "t ttt", + "t ii", + "t iiii", + "t rrrr", + "t rt", + "t rtrt", + "t rttt", + "t t", + "t t t", + "t t t", + "t tr", + "t trrr", + "t trrt", + "t tt", + "t tttt", + "t irrrr", + "t rrrr", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrti", + "t rrrtr", + "t rrt", + "t rrti", + "t rrtir", + "t rrtr", + "t rrtrr", + "t rrtrt", + "t rrttr", + "t rrttt", + "t rt", + "t rti", + "t rtrr", + "t rtrrr", + "t rtrrt", + "t rtrtr", + "t rtrtt", + "t rtt", + "t rtti", + "t rttt", + "t rtttt", + "t t", + "t t t", + "t t rt", + "t t t", + "t t tr", + "t t tt", + "t t i", + "t t rr", + "t t rrr", + "t t t", + "t t ttt", + "t ti", + "t trrr", + "t trrrr", + "t trrrt", + "t trrt", + "t trrtr", + "t trrtt", + "t trt", + "t trtr", + "t trtrr", + "t trtrt", + "t trtt", + "t trttr", + "t trttt", + "t tt", + "t tt t", + "t tt rt", + "t tti", + "t ttrrt", + "t ttt", + "t ttt t", + "t tttrr", + "t tttrt", + "t tttt", + "t ttttt", + "t i", + "t iii", + "t iiiiii", + "t iiittt", + "t it", + "t itiiii", + "t rr", + "t rrrr", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrtit", + "t rrrtr", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt r", + "t rrt rt", + "t rrti", + "t rrtitt", + "t rrtrr", + "t rrtrrr", + "t rrtrt", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrttrr", + "t rrttrt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt ii", + "t rt rr", + "t rt rrr", + "t rt rt", + "t rt rtr", + "t rt ttt", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrrti", + "t rtrrtr", + "t rtrt", + "t rtrtr", + "t rtrtrr", + "t rtrtti", + "t rtt", + "t rttrrr", + "t rttrrt", + "t rttrtt", + "t rttt", + "t rtttir", + "t rtttit", + "t rtttrt", + "t rtttt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t t t", + "t t rr", + "t t rrt", + "t t tr", + "t t trt", + "t t ttt", + "t t rr", + "t t rrr", + "t t rt", + "t t rtr", + "t t t", + "t t t r", + "t t trrr", + "t t ttt", + "t t tttt", + "t ti", + "t tiiii", + "t tiiiii", + "t titrr", + "t titt", + "t titttt", + "t tr", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrt", + "t trrtr", + "t trrtrr", + "t trrtrt", + "t trrttt", + "t trtrrr", + "t trtrrt", + "t trtrtr", + "t trtrtt", + "t trtt", + "t trttir", + "t trttrr", + "t trtttr", + "t trtttt", + "t tt", + "t tt tt", + "t tt t r", + "t tt tt", + "t tti", + "t ttiiii", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrt", + "t ttrrtt", + "t ttrtrr", + "t ttrtrt", + "t ttrttt", + "t ttt", + "t ttt tt", + "t tttiir", + "t tttiit", + "t tttrrr", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttti", + "t ttttir", + "t ttttit", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t tttttr", + "t tttttt", + "ti", + "ti i", + "ti r", + "ti t", + "ti tt", + "ti iiiii", + "ti ittii", + "ti rt tt", + "ti ttrrr", + "ti ttttr", + "tii", + "tii t", + "tii iiit", + "tii tiii", + "tii ttii", + "tiii", + "tiii tt", + "tiiii", + "tiiii ii", + "tiiiii", + "tiiiii i", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirtr", + "tiiiirtt", + "tiiiit", + "tiiiit t", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrti", + "tiiirrtr", + "tiiirrtt", + "tiiirt", + "tiiirtrr", + "tiiirttr", + "tiiirttt", + "tiiit", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrr", + "tiiitrrr", + "tiiitrrt", + "tiiitrtt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirittt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrtii", + "tiirrtrr", + "tiirrtrt", + "tiirrttt", + "tiirt", + "tiirtiii", + "tiirtirr", + "tiirtrrr", + "tiirtrtr", + "tiirtt", + "tiirtttr", + "tiirtttt", + "tiit", + "tiiti", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirr", + "tiitiit", + "tiitiiti", + "tiitiitt", + "tiitirrr", + "tiitirti", + "tiitit", + "tiititi", + "tiititii", + "tiititir", + "tiititit", + "tiititrr", + "tiititrt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrt", + "tiitrtii", + "tiitrtir", + "tiitrttt", + "tiitt", + "tiitti", + "tiittiii", + "tiittiit", + "tiittit", + "tiittiti", + "tiittitr", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrt", + "tiittrtt", + "tiittt", + "tiittti", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtii", + "tirrrtrr", + "tirrrtt", + "tirrrtti", + "tirrrttt", + "tirrt", + "tirrti", + "tirrtiii", + "tirrtirr", + "tirrtiti", + "tirrtitr", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrt", + "tirrtrtr", + "tirrtrtt", + "tirrttii", + "tirrttrr", + "tirrttrt", + "tirrttti", + "tirrtttr", + "tirrtttt", + "tirt", + "tirti", + "tirtiiii", + "tirtirrr", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrrtr", + "tirtrrtt", + "tirtrt", + "tirtrti", + "tirtrtit", + "tirtrtrr", + "tirtrtrt", + "tirtrtt", + "tirtrtti", + "tirtrttr", + "tirtrttt", + "tirtt", + "tirtt tt", + "tirttiii", + "tirttiir", + "tirttitr", + "tirttitt", + "tirttrrr", + "tirttrrt", + "tirttrti", + "tirttrtr", + "tirttt", + "tirtttit", + "tirtttrr", + "tirtttrt", + "tirtttt", + "tirtttti", + "tirttttt", + "tit", + "tit i", + "tit i", + "tit t t", + "tit tt", + "titi", + "titi ti", + "titii", + "titiii", + "titiiii", + "titiiiii", + "titiiiir", + "titiiiit", + "titiiit", + "titiiitr", + "titiiitt", + "titiit", + "titiitii", + "titiitit", + "titiitt", + "titiitti", + "titiittt", + "titirrrr", + "titirrt", + "titirtt", + "titit", + "tititi", + "tititiii", + "tititiit", + "tititirt", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititrrt", + "tititrtt", + "tititt", + "titittii", + "titittit", + "titittrr", + "titittrt", + "titittt", + "titittti", + "tititttt", + "titr", + "titrrrrr", + "titrrrrt", + "titrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrtrr", + "titrrtrt", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrti", + "titrtrrr", + "titrtrrt", + "titrtrt", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrttrr", + "titrttrt", + "titrttt", + "titrttti", + "titrtttr", + "titrtttt", + "titt", + "titt i", + "titt tit", + "titt tti", + "titti", + "titti t", + "titti ti", + "tittii", + "tittii t", + "tittiii", + "tittiiii", + "tittiiit", + "tittiiri", + "tittiirr", + "tittiit", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirrr", + "tittirtr", + "tittit", + "tittiti", + "tittitii", + "tittitit", + "tittitrr", + "tittitrt", + "tittitt", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrtr", + "tittrrtt", + "tittrt", + "tittrt r", + "tittrtrr", + "tittrtrt", + "tittrtt", + "tittrtti", + "tittrttr", + "tittrttt", + "tittt", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttirt", + "titttit", + "titttiti", + "titttitr", + "titttitt", + "titttrrr", + "titttrrt", + "titttrt", + "titttrtr", + "titttrtt", + "titttt", + "titttt t", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trr", + "trrr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt t", + "trrrt rr", + "trrrt rt", + "trrrt tr", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtirt", + "trrrtiti", + "trrrtitr", + "trrrtitt", + "trrrtr", + "trrrtrr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttr", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt rr", + "trrt t", + "trrt tr", + "trrt tt", + "trrt rrr", + "trrt t", + "trrt ttt", + "trrti", + "trrtii", + "trrtiiii", + "trrtiiir", + "trrtiirt", + "trrtiit", + "trrtiiti", + "trrtiitr", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirtr", + "trrtirtt", + "trrtit", + "trrtiti", + "trrtitii", + "trrtitit", + "trrtitrr", + "trrtitrt", + "trrtitti", + "trrtittr", + "trrtittt", + "trrtr", + "trrtrr", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt t", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt rr", + "trrtt tt", + "trrtti", + "trrttiii", + "trrttirr", + "trrttiti", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttti", + "trrtttii", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt tr", + "trt tt", + "trt rrr", + "trt rt", + "trt rtr", + "trt rtt", + "trt t", + "trt t r", + "trt trr", + "trt ttt", + "trt rrrr", + "trt rrrt", + "trt rrtr", + "trt rrtt", + "trt rtrt", + "trt rttr", + "trt rttt", + "trt t", + "trt t rr", + "trt titr", + "trt trrr", + "trt trrt", + "trt trtr", + "trt tt", + "trt tt t", + "trt tttt", + "trti", + "trtii", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiiiti", + "trtiiitr", + "trtiirrr", + "trtiirti", + "trtiirtr", + "trtiirtt", + "trtiitii", + "trtiitir", + "trtiitit", + "trtiitrt", + "trtiitti", + "trtiittt", + "trtirrrr", + "trtirrrt", + "trtirrtt", + "trtirtrr", + "trtirtrt", + "trtirtt", + "trtirttr", + "trtirttt", + "trtit", + "trtitii", + "trtitiit", + "trtititt", + "trtitrrr", + "trtitrtr", + "trtitt", + "trtittii", + "trtittit", + "trtittrr", + "trtittt", + "trtitttt", + "trtrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrti", + "trtrrtii", + "trtrrtir", + "trtrrtit", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt r", + "trtrt rr", + "trtrt rt", + "trtrt t", + "trtrt tt", + "trtrti", + "trtrtiii", + "trtrtiir", + "trtrtirr", + "trtrtirt", + "trtrtiti", + "trtrtitt", + "trtrtr", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtti", + "trtrttir", + "trtrttr", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rr", + "trtt rrt", + "trtt rtt", + "trtt trt", + "trtt ttt", + "trtti", + "trttii", + "trttiiii", + "trttiiir", + "trttiiit", + "trttiirr", + "trttiiti", + "trttiitr", + "trttiitt", + "trttirrr", + "trttirrt", + "trttirt", + "trttirti", + "trttirtr", + "trttirtt", + "trttit", + "trttitii", + "trttitrr", + "trttitrt", + "trttitt", + "trttitti", + "trttittt", + "trttrrr", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrtii", + "trttrtit", + "trttrtr", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt ii", + "trttt rr", + "trttt rt", + "trttt tr", + "trttt tt", + "trttti", + "trtttiir", + "trtttiit", + "trtttirr", + "trtttirt", + "trtttit", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt r", + "tt t", + "tt rr", + "tt rt", + "tt t", + "tt tr", + "tt tt", + "tt iii", + "tt rrr", + "tt rtt", + "tt trt", + "tt ttr", + "tt ttt", + "tt iiii", + "tt rr", + "tt rrrr", + "tt rrt", + "tt rrtr", + "tt rrtt", + "tt rtrt", + "tt rtt", + "tt rttt", + "tt t", + "tt t t", + "tt trr", + "tt trrr", + "tt trrt", + "tt trt", + "tt trtr", + "tt tt", + "tt tttr", + "tt tttt", + "tt i", + "tt itiii", + "tt itrtt", + "tt itttt", + "tt rrrr", + "tt rrrrr", + "tt rrrrt", + "tt rrrtr", + "tt rrt", + "tt rrtrr", + "tt rrtrt", + "tt rrtt", + "tt rrtti", + "tt rrttr", + "tt rrttt", + "tt rt", + "tt rt t", + "tt rt rr", + "tt rt t", + "tt rtrrr", + "tt rtrrt", + "tt rttrr", + "tt rttrt", + "tt rtttr", + "tt rtttt", + "tt t", + "tt t t", + "tt t r", + "tt t rr", + "tt t t", + "tt t rrr", + "tt t t", + "tt t ttt", + "tt trrrr", + "tt trrtr", + "tt trrtt", + "tt trt", + "tt trtrr", + "tt trtrt", + "tt trtt", + "tt trttt", + "tt tt", + "tt tt t", + "tt tt t", + "tt ttii", + "tt ttiit", + "tt ttrrt", + "tt ttrtt", + "tt ttt", + "tt ttt t", + "tt tttit", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti ii", + "tti ttt", + "tti itti", + "tti t", + "tti trr", + "tti trtr", + "tti tttt", + "ttii", + "ttii iii", + "ttii t", + "ttiii", + "ttiii r", + "ttiii t", + "ttiii tt", + "ttiiii", + "ttiiii t", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiir", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirti", + "ttiiirtt", + "ttiiit", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtr", + "ttiirrtt", + "ttiirtir", + "ttiirtrr", + "ttiirtrt", + "ttiirtt", + "ttiirtti", + "ttiirttt", + "ttiit", + "ttiit ii", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiit", + "ttiitit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitt t", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrti", + "ttirrtii", + "ttirrtit", + "ttirrtrr", + "ttirrtrt", + "ttirrtti", + "ttirrttt", + "ttirt", + "ttirtrrr", + "ttirtrrt", + "ttirtrti", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttii", + "ttirttrr", + "ttirttrt", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit t", + "ttit t", + "ttit iit", + "ttiti", + "ttiti ii", + "ttitii", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirt", + "ttitirtr", + "ttitirtt", + "ttitit", + "ttititi", + "ttititii", + "ttititit", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrtit", + "ttitrtrr", + "ttitrtrt", + "ttitrtt", + "ttitrtti", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt t", + "ttitt rt", + "ttitt tt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt i", + "ttittt t", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttr", + "ttrr", + "ttrrr", + "ttrrrr", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt rr", + "ttrrt tr", + "ttrrti", + "ttrrtii", + "ttrrtiii", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtiti", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt t", + "ttrt it", + "ttrt rr", + "ttrt tr", + "ttrt tt", + "ttrt rr", + "ttrt rrr", + "ttrt rrt", + "ttrt trr", + "ttrti", + "ttrtiii", + "ttrtiiii", + "ttrtiiit", + "ttrtiirr", + "ttrtiiti", + "ttrtirrr", + "ttrtirrt", + "ttrtirt", + "ttrtirtr", + "ttrtirtt", + "ttrtitrr", + "ttrtitt", + "ttrtitti", + "ttrtittr", + "ttrtittt", + "ttrtrr", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt t", + "ttrtrti", + "ttrtrtir", + "ttrtrtit", + "ttrtrtr", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt rt", + "ttrtt t", + "ttrtt tr", + "ttrtt tt", + "ttrtti", + "ttrttiii", + "ttrttiir", + "ttrttiit", + "ttrttirr", + "ttrttit", + "ttrttiti", + "ttrttitr", + "ttrttitt", + "ttrttr", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt t", + "ttrtttii", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt t", + "ttt rr", + "ttt rt", + "ttt t", + "ttt tt", + "ttt iii", + "ttt rrr", + "ttt rrt", + "ttt rt", + "ttt rtt", + "ttt t", + "ttt trr", + "ttt trt", + "ttt tt", + "ttt tti", + "ttt ttt", + "ttt iiii", + "ttt iiit", + "ttt ittt", + "ttt rr", + "ttt rrrr", + "ttt rrrt", + "ttt rrt", + "ttt rrtr", + "ttt rrtt", + "ttt rt r", + "ttt rt t", + "ttt rtrr", + "ttt rtrt", + "ttt rtt", + "ttt rttt", + "ttt t", + "ttt t r", + "ttt t r", + "ttt t rr", + "ttt t t", + "ttt t tr", + "ttt t tt", + "ttt trrt", + "ttt trtr", + "ttt tt", + "ttt tt r", + "ttt tt t", + "ttt tti", + "ttt ttit", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti t", + "ttti ti", + "ttti tt", + "ttti rtr", + "ttti trt", + "tttii", + "tttii t", + "tttii ti", + "tttii tt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirti", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrtr", + "tttirrtt", + "tttirt", + "tttirti", + "tttirtit", + "tttirtrr", + "tttirtrt", + "tttirtt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit t", + "tttit tt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirr", + "tttitirt", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrr", + "tttrrr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt t", + "tttrrti", + "tttrrtir", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt rr", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrtiii", + "tttrtirt", + "tttrtit", + "tttrtiti", + "tttrtitr", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtti", + "tttrttit", + "tttrttr", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt i", + "tttt r", + "tttt t", + "tttt i", + "tttt ii", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt i", + "tttt itr", + "tttt itt", + "tttt rrr", + "tttt rrt", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti t", + "tttti i", + "tttti tt", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttiti", + "ttttitii", + "ttttitir", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtir", + "ttttrtit", + "ttttrtr", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt i", + "ttttt ii", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttr", + "tttttrr", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr19": [ + "-1", + "-2", + "-6", + "i", + "i iii", + "i tttt", + "i iiii", + "i iiit", + "i ttiit", + "i tttt", + "i iiiiii", + "i iiiitt", + "i ittttt", + "i rrrrrr", + "i tttttt", + "ii", + "ii iii", + "ii ttt", + "ii iiii", + "ii iiiii", + "ii rrrti", + "ii rrrtt", + "ii t", + "ii t tt", + "ii tittt", + "ii ttiti", + "ii ttttt", + "iii", + "iii rrt", + "iii tti", + "iii iii", + "iii iiii", + "iii iiit", + "iii rrrr", + "iii rrrt", + "iii ttii", + "iiii", + "iiii i", + "iiii i i", + "iiii iii", + "iiii ttt", + "iiiii", + "iiiii i", + "iiiii i", + "iiiii ii", + "iiiii it", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiii r", + "iiiiii t", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrtr", + "iiiirrtt", + "iiiirti", + "iiiirtii", + "iiiirtir", + "iiiirtit", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiiti r", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitirr", + "iiiitirt", + "iiiitit", + "iiiititi", + "iiiititr", + "iiiititt", + "iiiitr", + "iiiitrrr", + "iiiitrrt", + "iiiitrti", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitt t", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrt r", + "iiirrtii", + "iiirrtit", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrttr", + "iiirrttt", + "iiirt", + "iiirtii", + "iiirtiii", + "iiirtiit", + "iiirtrrr", + "iiirtrrt", + "iiirtrtr", + "iiirtrtt", + "iiirtt", + "iiirttii", + "iiirttit", + "iiirttrr", + "iiirttti", + "iiirtttr", + "iiit", + "iiit ttt", + "iiiti", + "iiitii", + "iiitiii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitirrr", + "iiitirti", + "iiitit", + "iiititii", + "iiititit", + "iiititt", + "iiititti", + "iiitittr", + "iiitittt", + "iiitrrr", + "iiitrrrr", + "iiitrrrt", + "iiitrrti", + "iiitrrtr", + "iiitrtit", + "iiitrtrr", + "iiitrtrt", + "iiitrtt", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitti", + "iiittiii", + "iiittiit", + "iiittirr", + "iiittiti", + "iiittitr", + "iiittitt", + "iiittrr", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiittt t", + "iiittti", + "iiitttii", + "iiitttir", + "iiitttit", + "iiitttr", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtii", + "iirrrtrr", + "iirrrtrt", + "iirrrttt", + "iirrt", + "iirrtiii", + "iirrtrrr", + "iirrtrrt", + "iirrtrtr", + "iirrtrtt", + "iirrtt", + "iirrttii", + "iirrttrr", + "iirrtttt", + "iirt", + "iirti", + "iirtiiii", + "iirtirtt", + "iirtit", + "iirtitii", + "iirtrrrr", + "iirtrrrt", + "iirtrrtr", + "iirtrtrr", + "iirtrtrt", + "iirtrttt", + "iirtt", + "iirttii", + "iirttiii", + "iirttitr", + "iirttrrr", + "iirttrtr", + "iirttrtt", + "iirttt", + "iirtttir", + "iirtttrr", + "iirtttrt", + "iirttttr", + "iirttttt", + "iit", + "iit t", + "iit t", + "iit iit", + "iit tt", + "iit tttr", + "iiti", + "iitii", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiit", + "iitiiiti", + "iitiiitt", + "iitiirrr", + "iitiirrt", + "iitiirt", + "iitiit", + "iitiiti", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitrt", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitirrtr", + "iitirt", + "iitit", + "iititi", + "iititiii", + "iititiit", + "iititirt", + "iititit", + "iitititi", + "iitititt", + "iititt", + "iititti", + "iitittii", + "iitittit", + "iitittt", + "iitittti", + "iititttt", + "iitr", + "iitrr", + "iitrrrrr", + "iitrrrrt", + "iitrrrt", + "iitrrrti", + "iitrrrtr", + "iitrrrtt", + "iitrrtrr", + "iitrrtrt", + "iitrrtt", + "iitrrtti", + "iitrrttt", + "iitrt", + "iitrtiii", + "iitrtrrr", + "iitrtrrt", + "iitrtrtr", + "iitrtrtt", + "iitrtt", + "iitrttir", + "iitrttrr", + "iitrtttr", + "iitrtttt", + "iitt", + "iitt iti", + "iitt ttt", + "iitti", + "iittiii", + "iittiiii", + "iittiiit", + "iittiirt", + "iittiiti", + "iittiitr", + "iittiitt", + "iittit", + "iittitii", + "iittitir", + "iittitit", + "iittitrt", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrti", + "iittrrtr", + "iittrrtt", + "iittrti", + "iittrtii", + "iittrtir", + "iittrtrr", + "iittrtrt", + "iittrttt", + "iittt", + "iittti", + "iitttii", + "iitttiii", + "iitttiit", + "iitttirt", + "iitttit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "ir", + "irr", + "irrr", + "irrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrtii", + "irrrrtir", + "irrrrtit", + "irrrrtrt", + "irrrrtt", + "irrrrtti", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrtiir", + "irrrtirr", + "irrrtitr", + "irrrtitt", + "irrrtrrr", + "irrrtrrt", + "irrrtrt", + "irrrtrtr", + "irrrtrtt", + "irrrtt", + "irrrttit", + "irrrttrr", + "irrrttt", + "irrrtttt", + "irrt", + "irrti", + "irrtiii", + "irrtiiii", + "irrtiiit", + "irrtiiti", + "irrtiitr", + "irrtrrrr", + "irrtrrrt", + "irrtrrti", + "irrtrrtr", + "irrtrrtt", + "irrtrtit", + "irrtrttt", + "irrtt", + "irrttirr", + "irrttiti", + "irrttrrr", + "irrttrtt", + "irrttt", + "irrttti", + "irrtttrt", + "irrtttt", + "irrttttt", + "irt", + "irt ttt", + "irt iiii", + "irt rrt", + "irt tttt", + "irti", + "irtiiiii", + "irtiirrt", + "irtiitrt", + "irtirt i", + "irtirttr", + "irtitrrr", + "irtitrt", + "irtitt", + "irtitttt", + "irtrrrrr", + "irtrrrtt", + "irtrrtrt", + "irtrrtt", + "irtrrttt", + "irtrtirr", + "irtrtrrr", + "irtrtrrt", + "irtrtrt", + "irtrtrti", + "irtrtti", + "irtrttii", + "irtrttrr", + "irtrttrt", + "irtrttt", + "irtrtttt", + "irtt", + "irttiiit", + "irttiiti", + "irttirrr", + "irttitit", + "irttrtrr", + "irttrttt", + "irttt", + "irtttrrr", + "irtttrrt", + "irtttrtr", + "irtttt", + "irtttt t", + "irttttti", + "irtttttr", + "irtttttt", + "it", + "it t", + "it ttit", + "it tttr", + "it t", + "iti", + "iti rrrt", + "iti ttti", + "itii", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiirr", + "itiiiit", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiirrt", + "itiiirti", + "itiiirtt", + "itiiitii", + "itiiitir", + "itiiitit", + "itiiitrr", + "itiiitrt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirt", + "itiirtrr", + "itiirtti", + "itiit", + "itiit ii", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiitrrt", + "itiitrtt", + "itiitt", + "itiitti", + "itiittii", + "itiittir", + "itiittit", + "itiittti", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirrttr", + "itirt", + "itirtitt", + "itirtrrr", + "itirttii", + "itirtttt", + "itit", + "ititi", + "ititiiii", + "ititiit", + "ititiiti", + "ititiitt", + "ititirrr", + "ititit", + "itititi", + "itititit", + "itititrr", + "itititti", + "ititittr", + "ititittt", + "ititrrrt", + "ititrrti", + "ititrt", + "ititrti", + "ititrtr", + "ititrtrt", + "ititrtti", + "ititrttt", + "ititt", + "ititti", + "itittii", + "itittiii", + "itittiit", + "itittirr", + "itittirt", + "itittit", + "itittiti", + "itittitr", + "itittitt", + "itittrrr", + "itittrtt", + "itittt", + "itittti", + "ititttii", + "ititttit", + "ititttrt", + "ititttt", + "ititttti", + "itittttr", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrt r", + "itrrrtrr", + "itrrrtti", + "itrrrttr", + "itrrrttt", + "itrrt", + "itrrti", + "itrrtii", + "itrrtiii", + "itrrtiit", + "itrrtit", + "itrrtrrr", + "itrrtrrt", + "itrrtrtr", + "itrrtrtt", + "itrrtt t", + "itrrttrr", + "itrrttt", + "itrrtttt", + "itrt", + "itrt rt", + "itrti", + "itrtiiii", + "itrtiitr", + "itrtiitt", + "itrtirtt", + "itrtitii", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrtit", + "itrtrtrt", + "itrtrtt", + "itrtrtti", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrttirt", + "itrttrrr", + "itrttrt", + "itrttrti", + "itrttrtr", + "itrttrtt", + "itrtttrr", + "itrtttrt", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt trr", + "itt tt", + "itt iiii", + "itti", + "ittii", + "ittiiiii", + "ittiiiir", + "ittiiiit", + "ittiiirr", + "ittiiirt", + "ittiiit", + "ittiiiti", + "ittiiitt", + "ittiirrt", + "ittiit", + "ittiiti", + "ittiitii", + "ittiitit", + "ittiitrr", + "ittiitt", + "ittiitti", + "ittiittr", + "ittiittt", + "ittirrrr", + "ittirrt", + "ittirt", + "ittirtit", + "ittirtrr", + "ittirttr", + "ittit", + "ittitiii", + "ittitiit", + "ittitit", + "ittititi", + "ittititt", + "ittitrrr", + "ittitrtt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittrr", + "ittittt", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrtii", + "ittrrtrr", + "ittrrtti", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrtiii", + "ittrtitt", + "ittrtrrr", + "ittrtrtr", + "ittrtt", + "ittrttrr", + "ittrtttt", + "ittt", + "ittt t", + "ittt t", + "ittti", + "itttii", + "itttii t", + "itttiii", + "itttiiii", + "itttiiit", + "itttiit", + "itttiiti", + "itttiitr", + "itttiitt", + "itttirrr", + "itttit", + "itttitii", + "itttitit", + "itttitrr", + "itttitt", + "itttitti", + "itttittr", + "itttittt", + "itttrrr", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrt r", + "itttrtit", + "itttrtrr", + "itttrtrt", + "itttrttr", + "itttrttt", + "itttt", + "itttt t", + "itttt tt", + "itttti", + "ittttii", + "ittttiii", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrti", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rr", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt it", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt rr", + "rrrt i", + "rrrt irr", + "rrrt it", + "rrrt itt", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t t", + "rrrt ti", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti rr", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt t", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttr", + "rrrttrr", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt rr", + "rrt tr", + "rrt i", + "rrt rrr", + "rrt rrt", + "rrt rtr", + "rrt rtt", + "rrt t", + "rrt trr", + "rrt trt", + "rrt tt", + "rrt ttt", + "rrt i", + "rrt rrr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rt t", + "rrt rtir", + "rrt rtit", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rttt", + "rrt t", + "rrt t t", + "rrt t t", + "rrt ti", + "rrt trrr", + "rrt trrt", + "rrt trt", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt ttti", + "rrt tttt", + "rrti", + "rrti rr", + "rrti rt", + "rrtii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiirr", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitii", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirt r", + "rrtirtii", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirtt", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtititi", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtittii", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttt", + "rrtr", + "rrtrrr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt t", + "rrtrt i", + "rrtrt rr", + "rrtrt rt", + "rrtrt t", + "rrtrt tr", + "rrtrti", + "rrtrti t", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtitr", + "rrtrtitt", + "rrtrtrr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt t", + "rrtt tr", + "rrtt rrr", + "rrtt rrt", + "rrtt rtt", + "rrtt t", + "rrtt trr", + "rrtt tt", + "rrtt ttt", + "rrtti", + "rrtti ti", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrti", + "rrttrtii", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt t", + "rrttt rt", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt i", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt t", + "rt rt", + "rt rrr", + "rt rrt", + "rt ti", + "rt irrt", + "rt rrrr", + "rt rrtr", + "rt rtrr", + "rt t", + "rt trrt", + "rt trt", + "rt trtr", + "rt trtt", + "rt tt", + "rt ttrt", + "rt tttt", + "rt i", + "rt ii tt", + "rt iti", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rt rr", + "rt rtrrr", + "rt rtrrt", + "rt rtrtt", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t tt", + "rt t t", + "rt t trr", + "rt tirrr", + "rt trrrr", + "rt trrt", + "rt trrtt", + "rt trtrr", + "rt trttt", + "rt ttiti", + "rt ttt", + "rt tttrt", + "rt tttt", + "rt ttttt", + "rti", + "rti rtrr", + "rtii", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiiti", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirt", + "rtiiirtt", + "rtiiit", + "rtiiit t", + "rtiiitii", + "rtiiitrt", + "rtiiitti", + "rtiirrrr", + "rtiirrrt", + "rtiirrtr", + "rtiirt", + "rtiirti", + "rtiirtrr", + "rtiit", + "rtiiti", + "rtiitii", + "rtiitiii", + "rtiitirr", + "rtiititr", + "rtiitrrr", + "rtiitrrt", + "rtiitrti", + "rtiitt", + "rtiitt t", + "rtiittrr", + "rtiittrt", + "rtiitttr", + "rtir", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrti", + "rtirrtii", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrtti", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirt rr", + "rtirtiit", + "rtirtirr", + "rtirtrr", + "rtirtrrr", + "rtirtrrt", + "rtirtrtt", + "rtirtt", + "rtirttit", + "rtirttrt", + "rtirtttt", + "rtit", + "rtit itr", + "rtit rrt", + "rtiti", + "rtitii", + "rtitii i", + "rtitiiii", + "rtitiirt", + "rtitiitr", + "rtitiitt", + "rtitirtt", + "rtitit", + "rtititt", + "rtititti", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrti", + "rtitrtii", + "rtitrtrr", + "rtitrttr", + "rtitrttt", + "rtitt", + "rtitti", + "rtittiii", + "rtittiir", + "rtittiit", + "rtittirr", + "rtittit", + "rtittitt", + "rtittrrr", + "rtittrrt", + "rtittrt", + "rtittt", + "rtitttii", + "rtitttit", + "rtitttrt", + "rtitttti", + "rtittttr", + "rtittttt", + "rtr", + "rtrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitr", + "rtrrtitt", + "rtrrtrr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt r", + "rtrt t", + "rtrt t", + "rtrt tr", + "rtrt iii", + "rtrt rrr", + "rtrt rtr", + "rtrt rtt", + "rtrt t", + "rtrt trr", + "rtrt tt", + "rtrt tti", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiit", + "rtrtiirr", + "rtrtiirt", + "rtrtiitt", + "rtrtirrr", + "rtrtirti", + "rtrtirtt", + "rtrtit", + "rtrtitii", + "rtrtitit", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtittr", + "rtrtittt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt t", + "rtrtt rt", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttiit", + "rtrttirr", + "rtrttirt", + "rtrttit", + "rtrttitr", + "rtrttitt", + "rtrttrr", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt rr", + "rtt rrr", + "rtt rrt", + "rtt t", + "rtt trr", + "rtt ttr", + "rtt rrrr", + "rtt rrrt", + "rtt rrt", + "rtt rrtr", + "rtt rrtt", + "rtt rtrr", + "rtt t", + "rtt tiit", + "rtt trrt", + "rtt tt t", + "rtt tttr", + "rtt tttt", + "rtti", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirtr", + "rttiit", + "rttiiti", + "rttiitii", + "rttiitrr", + "rttiitrt", + "rttiitt", + "rttiitti", + "rttiittr", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrti", + "rttirrtt", + "rttirt", + "rttirtir", + "rttirtrt", + "rttirttr", + "rttirttt", + "rttit", + "rttit tt", + "rttitii", + "rttitiii", + "rttitiit", + "rttitit", + "rttititi", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitt", + "rttittii", + "rttittrr", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttr", + "rttrr", + "rttrrr", + "rttrrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrti", + "rttrrtii", + "rttrrtir", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrti", + "rttrtiii", + "rttrtiir", + "rttrtirr", + "rttrtit", + "rttrtitr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt r", + "rttrtti", + "rttrttii", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt rt", + "rttt tr", + "rttt rrr", + "rttt rrt", + "rttt t", + "rttt trt", + "rttt tt", + "rttt tti", + "rttt ttt", + "rttti", + "rtttii", + "rtttiii", + "rtttiiii", + "rtttiirr", + "rtttiirt", + "rtttiit", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirt", + "rtttirti", + "rtttirtt", + "rtttit", + "rtttiti", + "rtttitii", + "rtttitir", + "rtttitit", + "rtttitrr", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrtii", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt ir", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrit", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t t", + "t rt", + "t tr", + "t rrt", + "t t", + "t tr", + "t tt", + "t ttt", + "t rrrr", + "t rrrt", + "t rrtt", + "t rt", + "t rtr", + "t rtt", + "t t", + "t tr", + "t trrr", + "t trrt", + "t trt", + "t tt", + "t ttrt", + "t ttt", + "t ttti", + "t tttt", + "t rrr", + "t rrrr", + "t rrrrr", + "t rrrrt", + "t rrrtr", + "t rrt", + "t rt", + "t rtrrr", + "t rtrrt", + "t rtrti", + "t rtrtt", + "t rtt", + "t rtt t", + "t t", + "t t t", + "t t tr", + "t t tt", + "t t rr", + "t t ttt", + "t trrr", + "t trrrr", + "t trrtr", + "t trrtt", + "t trtrr", + "t trtrt", + "t trtt", + "t trttt", + "t tt", + "t tt t", + "t ttii", + "t ttt", + "t ttt r", + "t ttti", + "t tttrt", + "t tttt", + "t ttttt", + "t iii", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrti", + "t rrrtit", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrt tt", + "t rrtrrr", + "t rrtrt", + "t rrtrtr", + "t rrtt", + "t rrttrr", + "t rrttti", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt ii", + "t rt rt", + "t rt tt", + "t rtr", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrtrr", + "t rtt", + "t rttiii", + "t rttrt", + "t rttrtr", + "t rtttrt", + "t rtttt", + "t rttttt", + "t t", + "t t t", + "t t rr", + "t t t", + "t t tt", + "t t t", + "t t tir", + "t t trr", + "t t rrrr", + "t t rtrr", + "t t trr", + "t t trrt", + "t t trtt", + "t ti", + "t ti t r", + "t titttt", + "t trrrr", + "t trrrrr", + "t trrrrt", + "t trrrtr", + "t trrrtt", + "t trrtrr", + "t trrtt", + "t trrttt", + "t trt", + "t trtrrr", + "t trtrt", + "t trtrtt", + "t trtt", + "t trttrr", + "t trtttt", + "t tt", + "t tt r", + "t tt t", + "t ttii", + "t ttiiii", + "t ttiirt", + "t ttrrrr", + "t ttrrtt", + "t ttt", + "t ttt r", + "t ttt t", + "t tttitt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t ttttrr", + "t ttttrt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti t", + "ti itrr", + "ti rrrr", + "ti iii", + "ti rrrrt", + "ti rttt", + "ti tttii", + "tii", + "tiii", + "tiii tt", + "tiii iii", + "tiiii", + "tiiii ii", + "tiiiii", + "tiiiii i", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirti", + "tiiiirtt", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitir", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtt", + "tiiirt", + "tiiirt r", + "tiiirti", + "tiiirtrr", + "tiiirtrt", + "tiiirtt", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitirt", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrti", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtt", + "tiirrt", + "tiirrtrt", + "tiirrtt", + "tiirrtti", + "tiirrttr", + "tiirrttt", + "tiirt", + "tiirtiii", + "tiirtirr", + "tiirtit", + "tiirtrrr", + "tiirtrrt", + "tiirtt", + "tiirttir", + "tiirtttt", + "tiit", + "tiit ttt", + "tiiti", + "tiitii", + "tiitiiii", + "tiitiiir", + "tiitiiit", + "tiitiit", + "tiitiiti", + "tiitiitr", + "tiitiitt", + "tiitirrr", + "tiitirti", + "tiititi", + "tiititii", + "tiititit", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtt", + "tiitrtit", + "tiitrtrr", + "tiitrtrt", + "tiitrttr", + "tiitrttt", + "tiitt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiir", + "tiittiit", + "tiittirr", + "tiittitr", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrtr", + "tiittrtt", + "tiittt", + "tiittti", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrt r", + "tirrrtit", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrtti", + "tirrrttt", + "tirrt", + "tirrti", + "tirrtirr", + "tirrtiti", + "tirrtrrr", + "tirrtrtr", + "tirrtrtt", + "tirrttir", + "tirrttit", + "tirrtttr", + "tirrtttt", + "tirt", + "tirti", + "tirtiiii", + "tirtiiir", + "tirtiirr", + "tirtirrr", + "tirtirrt", + "tirtirti", + "tirtitrr", + "tirtitt", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrrtr", + "tirtrrtt", + "tirtrtrr", + "tirtrtrt", + "tirtrtt", + "tirtt", + "tirttirr", + "tirttt", + "tirttt t", + "tirttti", + "tirtttit", + "tirtttrt", + "tirtttt", + "tirttttr", + "tirttttt", + "tit", + "tit iiii", + "tit rtir", + "tit t", + "tit ttti", + "tit tttt", + "titi", + "titii", + "titiii", + "titiiii", + "titiiiii", + "titiiiit", + "titiiirr", + "titiiirt", + "titiiiti", + "titiiitr", + "titiiitt", + "titiirrt", + "titiit", + "titiiti", + "titiitit", + "titiitt", + "titiitti", + "titiittt", + "titirrrr", + "titirrrt", + "titirrtr", + "titirrtt", + "titirtti", + "titirttt", + "titit", + "tititi", + "tititii", + "tititiii", + "tititiir", + "tititiit", + "titititi", + "titititr", + "titititt", + "tititrtt", + "tititt", + "titittii", + "titittit", + "titittrr", + "titittrt", + "titittt", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrtr", + "titrrrtt", + "titrrtii", + "titrrtir", + "titrrtrr", + "titrrtrt", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrt rr", + "titrti", + "titrtiir", + "titrtirr", + "titrtrrr", + "titrtrrt", + "titrtrt", + "titrtrtt", + "titrttit", + "titrttrt", + "titrttt", + "titrtttt", + "titt", + "titt i", + "titt rt", + "titti", + "tittii", + "tittiii", + "tittiiii", + "tittiiit", + "tittiirr", + "tittiit", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirrr", + "tittirti", + "tittirtr", + "tittit", + "tittiti", + "tittitii", + "tittitit", + "tittitrr", + "tittitt", + "tittitti", + "tittittr", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrt", + "tittrrtr", + "tittrrtt", + "tittrt", + "tittrtii", + "tittrtit", + "tittrtrt", + "tittrttr", + "tittrttt", + "tittt", + "tittt tt", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttirr", + "titttirt", + "titttiti", + "titttitt", + "titttrrr", + "titttrrt", + "titttrt", + "titttrti", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt rr", + "trrrt t", + "trrrt tr", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiir", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtiti", + "trrrtitr", + "trrrtitt", + "trrrtrr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtti", + "trrrttii", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt r", + "trrt rr", + "trrt tr", + "trrt tt", + "trrt rrr", + "trrt t", + "trrt tr", + "trrt trr", + "trrt trt", + "trrt ttt", + "trrti", + "trrtii", + "trrtiii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirt", + "trrtiit", + "trrtiitr", + "trrtiitt", + "trrtirrr", + "trrtirti", + "trrtitrr", + "trrtitrt", + "trrtitt", + "trrtitti", + "trrtittt", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrti", + "trrtrtii", + "trrtrtr", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt tr", + "trrtti", + "trrttiii", + "trrttiir", + "trrttiit", + "trrttirr", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttti", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttr", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt r", + "trt t", + "trt r", + "trt rrr", + "trt trr", + "trt tt", + "trt iiii", + "trt rrrr", + "trt rrtr", + "trt rtrr", + "trt rttr", + "trt rttt", + "trt t", + "trt trrr", + "trt trtr", + "trti", + "trtii", + "trtiii", + "trtiiiii", + "trtiiirt", + "trtiiitt", + "trtiitrr", + "trtiitt", + "trtiittt", + "trtirrrr", + "trtirrrt", + "trtirrtt", + "trtirt", + "trtirtii", + "trtirtr", + "trtirtrr", + "trtirttt", + "trtit", + "trtiti", + "trtitiii", + "trtititt", + "trtitrti", + "trtitrtt", + "trtitt", + "trtittit", + "trtittrt", + "trtittt", + "trtitttr", + "trtitttt", + "trtr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrti", + "trtrrtii", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrti", + "trtrtiit", + "trtrtirr", + "trtrtirt", + "trtrtitr", + "trtrtitt", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtti", + "trtrttir", + "trtrttit", + "trtrttr", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rr", + "trtt rtr", + "trtt rtt", + "trtt t t", + "trtti", + "trttii", + "trttiiii", + "trttiirt", + "trttiitr", + "trttiitt", + "trttirrr", + "trttirtt", + "trttit", + "trttitir", + "trttitit", + "trttitrr", + "trttitrt", + "trttitt", + "trttitti", + "trttittr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrtii", + "trttrtit", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrttr", + "trttrttt", + "trttt", + "trttt rt", + "trttt t", + "trttt tt", + "trttti", + "trtttiii", + "trtttiir", + "trtttiit", + "trtttirr", + "trtttiti", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttr", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt r", + "tt iii", + "tt r", + "tt rrr", + "tt rtt", + "tt t", + "tt tr", + "tt trr", + "tt tt", + "tt ttt", + "tt rrrr", + "tt rrt", + "tt rrtt", + "tt rtrr", + "tt rtti", + "tt rttt", + "tt t", + "tt t t", + "tt tr", + "tt trrr", + "tt trtr", + "tt trtt", + "tt tt", + "tt ttt", + "tt tttr", + "tt tttt", + "tt i", + "tt it", + "tt itrrr", + "tt itttt", + "tt rrrrr", + "tt rrrrt", + "tt rrrti", + "tt rrrtr", + "tt rrrtt", + "tt rrt", + "tt rrtir", + "tt rrtrr", + "tt rrtrt", + "tt rrttt", + "tt rtrr", + "tt rtrt", + "tt rtrtr", + "tt rtrtt", + "tt rttrt", + "tt rtttt", + "tt t", + "tt t t", + "tt t rr", + "tt trrrr", + "tt trrt", + "tt trrtr", + "tt trrtt", + "tt trtt", + "tt trttt", + "tt tt", + "tt tt t", + "tt tt rr", + "tt tti", + "tt ttiii", + "tt ttiit", + "tt ttitt", + "tt ttrrr", + "tt ttrrt", + "tt ttrtt", + "tt ttt", + "tt tttii", + "tt tttr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti itti", + "tti t", + "tti ttii", + "tti tttt", + "ttii", + "ttiii", + "ttiii it", + "ttiiii", + "ttiiii i", + "ttiiiii", + "ttiiiiii", + "ttiiiiit", + "ttiiiirr", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtr", + "ttiiirtt", + "ttiiit", + "ttiiit t", + "ttiiiti", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrt", + "ttiirrti", + "ttiirrtt", + "ttiirtti", + "ttiirttr", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiit", + "ttiitit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrti", + "ttirrrtr", + "ttirrt", + "ttirrtrr", + "ttirrtrt", + "ttirrttr", + "ttirrttt", + "ttirt", + "ttirtiii", + "ttirtrrr", + "ttirtrt", + "ttirtrtr", + "ttirtt", + "ttirttii", + "ttirttrt", + "ttirttt", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit rrr", + "ttit tt", + "ttiti", + "ttitii", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiirt", + "ttitiit", + "ttitiiti", + "ttitiitr", + "ttitiitt", + "ttitirrr", + "ttitirti", + "ttitirtt", + "ttitit", + "ttititi", + "ttititii", + "ttititit", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtrt", + "ttitrtt", + "ttitrtti", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiir", + "ttittiit", + "ttittirr", + "ttittit", + "ttittiti", + "ttittitr", + "ttittitt", + "ttittrr", + "ttittrrr", + "ttittrrt", + "ttittrti", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt i", + "ttittt t", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrr", + "ttrrr", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt t", + "ttrrt tt", + "ttrrti", + "ttrrtiii", + "ttrrtiir", + "ttrrtiit", + "ttrrtirr", + "ttrrtiti", + "ttrrtitr", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt t", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt r", + "ttrt t", + "ttrt rrr", + "ttrt rtr", + "ttrt t", + "ttrt trr", + "ttrt ttt", + "ttrti", + "ttrti rr", + "ttrtiiii", + "ttrtiiit", + "ttrtiitt", + "ttrtirrr", + "ttrtit", + "ttrtiti", + "ttrtitit", + "ttrtitrr", + "ttrtitrt", + "ttrtitt", + "ttrtittr", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrtir", + "ttrtrtit", + "ttrtrtr", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt t", + "ttrtt tt", + "ttrtti", + "ttrtti t", + "ttrttiii", + "ttrttiti", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt t", + "ttt rt", + "ttt t", + "ttt tt", + "ttt rrr", + "ttt rrt", + "ttt t", + "ttt t t", + "ttt tii", + "ttt trt", + "ttt tt", + "ttt tti", + "ttt ttr", + "ttt ttt", + "ttt i", + "ttt rrrr", + "ttt rrrt", + "ttt rrtr", + "ttt rrtt", + "ttt rt", + "ttt rttr", + "ttt rttt", + "ttt t", + "ttt t t", + "ttt t rr", + "ttt t tt", + "ttt trrr", + "ttt trtr", + "ttt ttrr", + "ttt ttt", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti iii", + "ttti t", + "ttti trt", + "tttii", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiit", + "tttiiirr", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrti", + "tttirrtr", + "tttirrtt", + "tttirtit", + "tttirtrr", + "tttirtrt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit t", + "tttiti", + "tttitii", + "tttitiii", + "tttitiir", + "tttitiit", + "tttitirt", + "tttitit", + "tttititi", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrittr", + "tttrrr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt t", + "tttrrti", + "tttrrtii", + "tttrrtit", + "tttrrtr", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt t", + "tttrt rr", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrtiii", + "tttrtiit", + "tttrtirt", + "tttrtitt", + "tttrtrr", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt t", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt i", + "tttt r", + "tttt t", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt i", + "tttt iii", + "tttt itt", + "tttt rrr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt tii", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti tt", + "ttttii", + "ttttii t", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirti", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttit i", + "ttttiti", + "ttttitii", + "ttttitir", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttr", + "ttttrrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt i", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtii", + "ttttrtir", + "ttttrtit", + "ttttrtr", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr20": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i r", + "i t", + "i i", + "i ii", + "i ir", + "i it", + "i rt", + "i t", + "i tr", + "i i", + "i iii", + "i irr", + "i it", + "i itr", + "i itt", + "i rrr", + "i trr", + "i tt", + "i ttr", + "i ttt", + "i i", + "i i tt", + "i ii", + "i iii", + "i iiii", + "i iirr", + "i irrr", + "i irrt", + "i irtr", + "i irtt", + "i itii", + "i itrr", + "i itt", + "i ittr", + "i ittt", + "i rrrr", + "i rrrt", + "i rt", + "i t t", + "i trrr", + "i tt", + "i ttt", + "i tttr", + "i tttt", + "i i", + "i i iii", + "i i rrr", + "i i ttr", + "i i ttt", + "i ii", + "i iiii", + "i iiiii", + "i iiiit", + "i iiiti", + "i iiitr", + "i iirrr", + "i iitii", + "i iitt", + "i iittt", + "i irrrr", + "i irrrt", + "i irrtr", + "i irrtt", + "i irtii", + "i irtrr", + "i irtrt", + "i irtt", + "i irttt", + "i it", + "i it tt", + "i itit", + "i ititt", + "i itrrr", + "i itrrt", + "i itrtt", + "i itt", + "i ittii", + "i ittrr", + "i ittt", + "i ittti", + "i itttr", + "i itttt", + "i rrrrr", + "i rrrrt", + "i rrtrr", + "i rrttr", + "i rrttt", + "i rttrt", + "i rttt", + "i rtttr", + "i rtttt", + "i trrrr", + "i tt", + "i tti", + "i ttrtr", + "i tttti", + "i ttttr", + "i ttttt", + "i i", + "i i iii", + "i i iii", + "i i iiii", + "i i rrrr", + "i i tt t", + "i ii", + "i ii iii", + "i iii", + "i iii ii", + "i iiii", + "i iiiii", + "i iiiiii", + "i iiiiir", + "i iiiiit", + "i iiiirr", + "i iiiitr", + "i iiiitt", + "i iiitti", + "i iirrrr", + "i iirrtr", + "i iirtrt", + "i iirttr", + "i iit tt", + "i iitirt", + "i iitrtr", + "i iittii", + "i iitttt", + "i irrrrr", + "i irrrrt", + "i irrrtr", + "i irrtrt", + "i irrttr", + "i irrttt", + "i irt rr", + "i irt tr", + "i irtrrr", + "i irtrrt", + "i irttrr", + "i irtttt", + "i it", + "i it tt", + "i itittt", + "i itrrrr", + "i itrrrt", + "i itrrtt", + "i itrtrt", + "i itrttt", + "i itt", + "i itt r", + "i ittiii", + "i ittrtr", + "i itttrt", + "i itttt", + "i itttti", + "i ittttt", + "i rrrrrr", + "i rrrrrt", + "i rrtrrr", + "i rrtttt", + "i rt tt", + "i rtrrrr", + "i rtrt", + "i t", + "i tiiiir", + "i trrrrr", + "i trrrtr", + "i trrrtt", + "i trrttt", + "i ttrrrt", + "i ttrt", + "i ttrtt", + "i ttrttr", + "i ttrttt", + "i ttt", + "i tttrrt", + "i tttt", + "i ttttii", + "i tttttt", + "ii", + "ii i", + "ii r", + "ii ii", + "ii iii", + "ii i", + "ii t", + "ii i", + "ii iii", + "ii iiiii", + "ii iiitt", + "ii irtit", + "ii rrtrr", + "ii t", + "ii ti ii", + "ii tt", + "ii ttii", + "ii ttiii", + "ii ttitt", + "ii ttrtt", + "ii tttii", + "ii tttit", + "ii tttrt", + "ii ttttt", + "iii", + "iii i", + "iii ttt", + "iii i", + "iii i ii", + "iii iii", + "iii iiii", + "iii iitt", + "iii t", + "iii tttt", + "iiii", + "iiii i", + "iiii ii", + "iiii tr", + "iiii tt", + "iiii ii", + "iiii iii", + "iiii iir", + "iiii iit", + "iiii irr", + "iiii itr", + "iiii rrt", + "iiii rtr", + "iiii rtt", + "iiii t", + "iiiii", + "iiiii i", + "iiiii ii", + "iiiii ir", + "iiiii t", + "iiiii ti", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiii t", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiit t", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirt", + "iiiirtii", + "iiiirtir", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirtti", + "iiiirttt", + "iiiit", + "iiiit ii", + "iiiiti", + "iiiiti i", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitirr", + "iiiititi", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiittii", + "iiiittir", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrti", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtrr", + "iiirrtrt", + "iiirrttt", + "iiirt", + "iiirtii", + "iiirtiii", + "iiirtiir", + "iiirtiit", + "iiirtrrr", + "iiirtrrt", + "iiirtrtr", + "iiirtrtt", + "iiirttii", + "iiirttit", + "iiirttrr", + "iiirttti", + "iiirtttr", + "iiirtttt", + "iiit", + "iiit iit", + "iiit tti", + "iiiti", + "iiitii", + "iiitii i", + "iiitiii", + "iiitiiii", + "iiitiiit", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitirrt", + "iiitirtt", + "iiitit", + "iiititii", + "iiititit", + "iiititrt", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrt i", + "iiitrtrr", + "iiitrtrt", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitti", + "iiittiii", + "iiittiir", + "iiittirr", + "iiittirt", + "iiittiti", + "iiittitr", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrt t", + "iirrrtii", + "iirrrtir", + "iirrrtrr", + "iirrrtrt", + "iirrrtt", + "iirrrttr", + "iirrrttt", + "iirrt", + "iirrt rr", + "iirrtii", + "iirrtiii", + "iirrtirt", + "iirrtrrr", + "iirrtrrt", + "iirrtrtr", + "iirrtrtt", + "iirrttrr", + "iirrttrt", + "iirrttti", + "iirrtttr", + "iirrtttt", + "iirt", + "iirt rr", + "iirt iii", + "iirt rrr", + "iirt rtr", + "iirtiii", + "iirtiiii", + "iirtiiir", + "iirtiirr", + "iirtiiti", + "iirtirrt", + "iirtirti", + "iirtittt", + "iirtrrrr", + "iirtrrrt", + "iirtrrt", + "iirtrrti", + "iirtrrtr", + "iirtrrtt", + "iirtrtrr", + "iirtrtti", + "iirtrttt", + "iirtt", + "iirtti", + "iirttiii", + "iirttrrr", + "iirttrrt", + "iirttrtt", + "iirttt", + "iirttt r", + "iirtttrr", + "iirtttti", + "iirttttt", + "iit", + "iit t", + "iit iiii", + "iit rrrt", + "iit t", + "iiti", + "iitii", + "iitiiii", + "iitiiiii", + "iitiiiir", + "iitiiiit", + "iitiiirt", + "iitiiiti", + "iitiiitt", + "iitiirti", + "iitiirtt", + "iitiitii", + "iitiitit", + "iitiitt", + "iitiittr", + "iitiittt", + "iitirrrr", + "iitirrtt", + "iitit", + "iititi", + "iititii", + "iititiii", + "iititiit", + "iititirr", + "iitititi", + "iitititt", + "iititrti", + "iitittii", + "iitittir", + "iitittit", + "iitittrr", + "iitittrt", + "iitittti", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrt", + "iitrrrti", + "iitrrrtr", + "iitrrrtt", + "iitrrtii", + "iitrrtrr", + "iitrrtrt", + "iitrrtt", + "iitrrttt", + "iitrt", + "iitrt rr", + "iitrtiii", + "iitrtrrr", + "iitrtrrt", + "iitrtrt", + "iitrtrtr", + "iitrtrtt", + "iitrttit", + "iitrttrr", + "iitrttrt", + "iitrttt", + "iitrttti", + "iitrtttr", + "iitrtttt", + "iitt", + "iitt i", + "iitt t", + "iitt rtr", + "iitt trr", + "iitti", + "iitti tt", + "iittiiii", + "iittiiit", + "iittiiti", + "iittiitt", + "iittirrr", + "iittirti", + "iittirtt", + "iittit", + "iittitii", + "iittitit", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrt", + "iittrrtr", + "iittrrtt", + "iittrt", + "iittrtir", + "iittrtrr", + "iittrtrt", + "iittrtt", + "iittrttt", + "iittt", + "iittt i", + "iittt rr", + "iittt t", + "iittti", + "iitttiii", + "iitttiit", + "iitttirr", + "iitttit", + "iitttiti", + "iitttitr", + "iitttitt", + "iitttrrt", + "iitttrt", + "iitttrtt", + "iitttt", + "iittttii", + "iittttir", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrt r", + "irrrrtii", + "irrrrtit", + "irrrrtrr", + "irrrrtrt", + "irrrrtti", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrt tr", + "irrrti", + "irrrtii", + "irrrtiii", + "irrrtiit", + "irrrtitr", + "irrrtrrr", + "irrrtrrt", + "irrrtrt", + "irrrtrtr", + "irrrtt r", + "irrrtti", + "irrrttii", + "irrrttrr", + "irrrttrt", + "irrrttt", + "irrrtttr", + "irrrtttt", + "irrt", + "irrt ii", + "irrt rt", + "irrt tr", + "irrt itt", + "irrt rrr", + "irrt rtr", + "irrt tir", + "irrti", + "irrtiii", + "irrtiiii", + "irrtiirr", + "irrtirrr", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrti", + "irrtrrtr", + "irrtrrtt", + "irrtrt", + "irrtrtrr", + "irrtrtrt", + "irrtrttr", + "irrtrttt", + "irrtt", + "irrttiir", + "irrttirr", + "irrttitt", + "irrttrrt", + "irrttrt", + "irrttrtr", + "irrttrtt", + "irrtttii", + "irrtttir", + "irrtttit", + "irrtttrr", + "irrtttrt", + "irrtttt", + "irrttttr", + "irrttttt", + "irt", + "irt rtr", + "irt rrrr", + "irt rrtt", + "irt tttt", + "irti", + "irtiiiii", + "irtiiiit", + "irtiittt", + "irtirrrr", + "irtirrrt", + "irtirrti", + "irtirtrt", + "irtit", + "irtit t", + "irtitiii", + "irtititi", + "irtititt", + "irtitrrt", + "irtitrtt", + "irtittit", + "irtrrrrr", + "irtrrrtr", + "irtrrrtt", + "irtrrt", + "irtrrtii", + "irtrrtir", + "irtrrtrt", + "irtrrtti", + "irtrrttr", + "irtrt", + "irtrti", + "irtrtiii", + "irtrtrrr", + "irtrtrrt", + "irtrtrt", + "irtrtrtr", + "irtrtrtt", + "irtrttii", + "irtrttrr", + "irtrttrt", + "irtrtttr", + "irtrtttt", + "irtt", + "irtt tr", + "irtt rrt", + "irtt trr", + "irttii", + "irttiiii", + "irttiirr", + "irttirtt", + "irttitt", + "irttrrrr", + "irttrrrt", + "irttrrtt", + "irttrtit", + "irttrtrr", + "irttrttr", + "irttt", + "irtttirt", + "irtttitt", + "irtttrrr", + "irtttrtr", + "irtttrtt", + "irtttt", + "irtttt t", + "irttttrr", + "irttttrt", + "irttttt", + "irtttttr", + "irtttttt", + "it", + "it i", + "it ii", + "it rttt", + "it tttt", + "it iiiii", + "it ittii", + "it rrrtt", + "it rrtrt", + "it rt", + "it rtrrr", + "it trrtr", + "it ttrtt", + "it tttit", + "iti", + "iti tttr", + "itii", + "itii i", + "itiii", + "itiiii", + "itiiiiii", + "itiiiiit", + "itiiiirt", + "itiiiit", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiirtt", + "itiiit", + "itiiitii", + "itiiitit", + "itiiitrt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirrt", + "itiirrtr", + "itiirtrr", + "itiit", + "itiitiii", + "itiitit", + "itiititi", + "itiititt", + "itiitrrt", + "itiitrtr", + "itiitt", + "itiitt r", + "itiittii", + "itiittrr", + "itiittt", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrti", + "itirrrtr", + "itirrrtt", + "itirrtrt", + "itirrtt", + "itirttt", + "itirtttt", + "itit", + "itit tit", + "ititi", + "ititiiii", + "ititiiit", + "ititiitt", + "ititit", + "itititit", + "itititti", + "ititittt", + "ititrrrr", + "ititrrti", + "ititrrtr", + "ititrrtt", + "ititrt", + "ititrtii", + "ititrtit", + "ititrtrr", + "ititrtt", + "ititt", + "itittiir", + "itittiit", + "itittiti", + "itittitt", + "itittt", + "itittti", + "ititttii", + "ititttit", + "ititttrr", + "ititttrt", + "ititttti", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrt t", + "itrrrtrr", + "itrrrtrt", + "itrrrttr", + "itrrrttt", + "itrrt", + "itrrtiir", + "itrrtiti", + "itrrtitt", + "itrrtrrr", + "itrrtrtt", + "itrrtt", + "itrrttrr", + "itrrttt", + "itrrttti", + "itrrtttr", + "itrrtttt", + "itrt", + "itrt itt", + "itrt trr", + "itrt trt", + "itrtirrr", + "itrtit", + "itrtittr", + "itrtrrrr", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrtit", + "itrtrtrr", + "itrtrtrt", + "itrtrtt", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrttirr", + "itrttrrr", + "itrttrrt", + "itrttrt", + "itrttrtt", + "itrttt", + "itrtttir", + "itrtttit", + "itrtttrr", + "itrtttrt", + "itrtttt", + "itrttttr", + "itrttttt", + "itt", + "itt t", + "itt rtt", + "itt irrr", + "itt rtrr", + "itt t", + "itt titi", + "itt ttrr", + "itt tttr", + "itt tttt", + "itti", + "itti ttt", + "ittii", + "ittiii t", + "ittiiii", + "ittiiiii", + "ittiiiir", + "ittiiiit", + "ittiiiti", + "ittiiitt", + "ittiirtt", + "ittiit", + "ittiitii", + "ittiitit", + "ittiitrt", + "ittiitti", + "ittiittt", + "ittirrrr", + "ittirrrt", + "ittirrt", + "ittirrtt", + "ittirtrr", + "ittirtt", + "ittirttt", + "ittit", + "ittiti i", + "ittitiii", + "ittitiit", + "ittititi", + "ittititt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrt", + "ittrrrtt", + "ittrrt", + "ittrrt t", + "ittrrtrr", + "ittrrtrt", + "ittrrtt", + "ittrrtti", + "ittrrttt", + "ittrt", + "ittrt tr", + "ittrtirr", + "ittrtrrr", + "ittrtrrt", + "ittrtrt", + "ittrtrtr", + "ittrtrtt", + "ittrttii", + "ittrttrr", + "ittrttrt", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt tt", + "ittt iti", + "ittt tti", + "ittti", + "itttii", + "itttii i", + "itttiiii", + "itttiiit", + "itttiirr", + "itttiit", + "itttiiti", + "itttiitt", + "itttirti", + "itttit", + "itttitii", + "itttitir", + "itttitit", + "itttitt", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrtrr", + "itttrtrt", + "itttrtt", + "itttrttr", + "itttrttt", + "itttt", + "itttti", + "ittttii", + "ittttiii", + "ittttiit", + "ittttirt", + "ittttit", + "ittttiti", + "ittttitr", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrti", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt r", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt i", + "rrrrt r", + "rrrrt t", + "rrrrt i", + "rrrrt ii", + "rrrrt ir", + "rrrrt it", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt ti", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrti r", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt i", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt ii", + "rrrt ir", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt tr", + "rrrt i", + "rrrt iii", + "rrrt iir", + "rrrt irr", + "rrrt irt", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t i", + "rrrt tii", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtit r", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt t", + "rrrtt i", + "rrrtt ir", + "rrrtt it", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt ii", + "rrt it", + "rrt rr", + "rrt iii", + "rrt rrr", + "rrt rtt", + "rrt t", + "rrt tt", + "rrt ttt", + "rrt i", + "rrt i ir", + "rrt irtr", + "rrt it", + "rrt itti", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrti", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rtrr", + "rrt rtrt", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t rr", + "rrt tiii", + "rrt trrr", + "rrt trrt", + "rrt trt", + "rrt trti", + "rrt trtr", + "rrt trtt", + "rrt tt", + "rrt ttrr", + "rrt ttrt", + "rrt ttti", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti ii", + "rrti rt", + "rrtii", + "rrtii rr", + "rrtiii", + "rrtiii i", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirti", + "rrtirtii", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirtt", + "rrtirtti", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitiii", + "rrtitiit", + "rrtitirr", + "rrtitirt", + "rrtitit", + "rrtititi", + "rrtititr", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtittii", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtitttr", + "rrtitttt", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt t", + "rrtrt it", + "rrtrt rr", + "rrtrt rt", + "rrtrt t", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtitr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt ii", + "rrtt rr", + "rrtt rt", + "rrtt t", + "rrtt tr", + "rrtt irt", + "rrtt itt", + "rrtt rrr", + "rrtt rrt", + "rrtt rt", + "rrtt rtr", + "rrtt rtt", + "rrtt t", + "rrtt t r", + "rrtt trr", + "rrtt trt", + "rrtt tt", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiit", + "rrttiiti", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit r", + "rrttiti", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt ii", + "rrttt rr", + "rrttt rt", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt t", + "rt i", + "rt ii", + "rt ir", + "rt rr", + "rt rt", + "rt t", + "rt iir", + "rt itt", + "rt t", + "rt ttt", + "rt itrr", + "rt rrrr", + "rt rtt", + "rt trt", + "rt tt", + "rt i", + "rt iiiii", + "rt iiiit", + "rt iirtt", + "rt irrrr", + "rt irtrr", + "rt irttr", + "rt it", + "rt ittti", + "rt itttt", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtit", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rti", + "rt rtirr", + "rt rtrrr", + "rt rtrrt", + "rt rtrt", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rttrr", + "rt rtttt", + "rt t", + "rt t t", + "rt t rr", + "rt t rt", + "rt t t", + "rt t tr", + "rt t tt", + "rt t rrr", + "rt t trt", + "rt t ttr", + "rt t ttt", + "rt trrrr", + "rt trrrt", + "rt trrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trt t", + "rt trtrr", + "rt trtrt", + "rt trttr", + "rt trttt", + "rt tt", + "rt ttiii", + "rt ttirr", + "rt ttiti", + "rt ttrrr", + "rt ttrrt", + "rt ttrt", + "rt ttrtr", + "rt ttrtt", + "rt ttt", + "rt tttrr", + "rt tttt", + "rt ttttr", + "rt ttttt", + "rti", + "rtii", + "rtii tr", + "rtii rrr", + "rtii tt", + "rtiii", + "rtiii i", + "rtiii ii", + "rtiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitr", + "rtiiirrr", + "rtiiirrt", + "rtiiirt", + "rtiiirtr", + "rtiiirtt", + "rtiiit", + "rtiiiti", + "rtiiitii", + "rtiiitti", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirrtr", + "rtiirrtt", + "rtiirt", + "rtiirt r", + "rtiirtii", + "rtiirtit", + "rtiirtrr", + "rtiirtrt", + "rtiirttt", + "rtiit", + "rtiitiii", + "rtiitiir", + "rtiitiit", + "rtiitirt", + "rtiitit", + "rtiititt", + "rtiitrrr", + "rtiitrrt", + "rtiitrt", + "rtiitrti", + "rtiitrtr", + "rtiitt", + "rtiitt i", + "rtiittii", + "rtiittit", + "rtiittrr", + "rtiittrt", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt r", + "rtirrti", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrtti", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirtiii", + "rtirtrrr", + "rtirtrrt", + "rtirtrtt", + "rtirtt", + "rtirttit", + "rtirttrr", + "rtirttrt", + "rtirtttt", + "rtit", + "rtit tt", + "rtit itr", + "rtit itt", + "rtiti", + "rtitiii", + "rtitiiii", + "rtitiirr", + "rtitiit", + "rtitiiti", + "rtitiitt", + "rtitirrr", + "rtitirrt", + "rtitirtt", + "rtititii", + "rtititrr", + "rtititt", + "rtititti", + "rtitrrrr", + "rtitrrtr", + "rtitrrtt", + "rtitrtir", + "rtitrtt", + "rtitrttt", + "rtitt", + "rtitti", + "rtittiii", + "rtittitr", + "rtittitt", + "rtittrrr", + "rtittrrt", + "rtittrtr", + "rtittrtt", + "rtittt", + "rtitttii", + "rtitttit", + "rtitttrt", + "rtitttt", + "rtitttti", + "rtittttr", + "rtittttt", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitr", + "rtrrtitt", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt rr", + "rtrt rt", + "rtrt t", + "rtrt tr", + "rtrt irr", + "rtrt itr", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rtr", + "rtrt rtt", + "rtrt t", + "rtrt tii", + "rtrt tit", + "rtrt trr", + "rtrt trt", + "rtrt tt", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiiii", + "rtrtiirr", + "rtrtiirt", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtitii", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtitti", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrt t", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt r", + "rtrtt t", + "rtrtt rr", + "rtrtt rt", + "rtrtt tr", + "rtrtt tt", + "rtrtti", + "rtrttiii", + "rtrttiir", + "rtrttirr", + "rtrttirt", + "rtrttit", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt i", + "rtrttt r", + "rtrttt t", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt ii", + "rtt it", + "rtt rr", + "rtt t", + "rtt rrr", + "rtt rrt", + "rtt rtr", + "rtt rtt", + "rtt trr", + "rtt tt", + "rtt i", + "rtt iitr", + "rtt irrr", + "rtt rrrr", + "rtt rrrt", + "rtt rrtr", + "rtt rrtt", + "rtt rtrr", + "rtt rtrt", + "rtt rttr", + "rtt t", + "rtt t tr", + "rtt t tt", + "rtt trrr", + "rtt trrt", + "rtt trt", + "rtt trtr", + "rtt trtt", + "rtt tt", + "rtt ttrr", + "rtt ttrt", + "rtt ttt", + "rtt tttt", + "rtti", + "rtti rt", + "rtti iit", + "rtti t t", + "rttii", + "rttii ii", + "rttii t", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiirt", + "rttiiit", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirt", + "rttiirti", + "rttiit", + "rttiitii", + "rttiitit", + "rttiitrr", + "rttiitrt", + "rttiittr", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrtr", + "rttirrtt", + "rttirtii", + "rttirtit", + "rttirtrt", + "rttirtt", + "rttirtti", + "rttirttr", + "rttit", + "rttiti", + "rttitirr", + "rttititi", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrti", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttittii", + "rttittrr", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrti", + "rttrrtii", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt rr", + "rttrt rt", + "rttrt t", + "rttrt tr", + "rttrt tt", + "rttrti", + "rttrtii", + "rttrtiii", + "rttrtirr", + "rttrtit", + "rttrtitr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt t", + "rttrtti", + "rttrttii", + "rttrttir", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt ii", + "rttt it", + "rttt rrr", + "rttt rrt", + "rttt rtt", + "rttt tii", + "rttt trr", + "rttt trt", + "rttt tti", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttiii", + "rtttiiii", + "rtttiiir", + "rtttiiit", + "rtttiirt", + "rtttiit", + "rtttiiti", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitir", + "rtttitit", + "rtttitrr", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrt t", + "rtttrti", + "rtttrtii", + "rtttrtir", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt i", + "rtttt r", + "rtttt t", + "rtttt i", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt tr", + "rtttt tt", + "rtttti", + "rtttti i", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt r", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t i", + "t r", + "t t", + "t i", + "t ii", + "t ir", + "t it", + "t rr", + "t rt", + "t t", + "t ti", + "t tr", + "t tt", + "t iii", + "t irt", + "t rrr", + "t rrt", + "t rtr", + "t t t", + "t trr", + "t trt", + "t rrrr", + "t rrrt", + "t rti", + "t rtt", + "t t rr", + "t trrr", + "t trrt", + "t trti", + "t tt", + "t ttii", + "t tttt", + "t ii", + "t iii", + "t iiiii", + "t iiiit", + "t iiiti", + "t iiitr", + "t iirrr", + "t irrrr", + "t irrrt", + "t irtii", + "t irtrt", + "t irttr", + "t it ii", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrti", + "t rrrtr", + "t rrrtt", + "t rrt", + "t rrt r", + "t rrtrr", + "t rrttt", + "t rt", + "t rtiit", + "t rtit", + "t rtrrr", + "t rtrrt", + "t rtrt", + "t rtrtr", + "t rttt", + "t rtttr", + "t t", + "t t rr", + "t t rt", + "t t tr", + "t t tt", + "t t tii", + "t ti", + "t trrrr", + "t trt", + "t trtrt", + "t trttt", + "t tt", + "t ttiit", + "t ttt", + "t tttrt", + "t ttttt", + "t i", + "t i t", + "t i rt", + "t i ttt", + "t ii", + "t iii", + "t iiiiii", + "t iiiirr", + "t iiittt", + "t iirrtt", + "t iirttt", + "t iitrtr", + "t irrrrr", + "t irt", + "t irtrrr", + "t it", + "t itiiii", + "t itiiir", + "t itirrr", + "t itirtt", + "t ititii", + "t ititir", + "t itrrtt", + "t ittrrr", + "t ittti", + "t ittttt", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrt r", + "t rrrtii", + "t rrrtir", + "t rrrtit", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrti", + "t rrtiir", + "t rrtirr", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrti", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrtt t", + "t rrttii", + "t rrttrr", + "t rrttrt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt rt", + "t rt tr", + "t rt rrr", + "t rt rtr", + "t rt t", + "t rtiirr", + "t rtirrr", + "t rtrrrr", + "t rtrrrt", + "t rtrrt", + "t rtrrti", + "t rtrrtr", + "t rtrrtt", + "t rtrtir", + "t rtrtrr", + "t rtrtrt", + "t rtrtti", + "t rtrttr", + "t rtrttt", + "t rtt", + "t rtt t", + "t rtt tt", + "t rtti", + "t rttrrr", + "t rttrtr", + "t rttrtt", + "t rttt", + "t rtttit", + "t rtttrr", + "t rtttrt", + "t rtttt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t t t", + "t t t", + "t t rrrr", + "t t rtrt", + "t t rttt", + "t t t", + "t t trrt", + "t t trtr", + "t t ttt", + "t ti", + "t tiiiii", + "t tirtir", + "t tirtrt", + "t tit", + "t titiii", + "t titrrr", + "t titrtr", + "t tittit", + "t tittt", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrt r", + "t trrtrr", + "t trrtrt", + "t trrtt", + "t trrttr", + "t trrttt", + "t trt", + "t trtiit", + "t trtirr", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrti", + "t trtrtr", + "t trtrtt", + "t trtt", + "t trttrr", + "t trttrt", + "t trttt", + "t trtttr", + "t trtttt", + "t tt", + "t tt r", + "t tt tti", + "t tti", + "t tti ii", + "t ttiiii", + "t ttiiit", + "t ttitt", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrt", + "t ttrrtr", + "t ttrrtt", + "t ttrti", + "t ttrtrr", + "t ttrtrt", + "t ttrttr", + "t ttrttt", + "t ttt", + "t ttt t", + "t ttt t", + "t tttiii", + "t tttiit", + "t tttit", + "t tttiti", + "t tttrrr", + "t tttrrt", + "t tttrti", + "t tttrtr", + "t tttrtt", + "t tttt", + "t ttttii", + "t ttttit", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti i", + "ti trt", + "ti iitrr", + "ti iittt", + "ti irrrr", + "ti tittt", + "ti trtrt", + "ti trttt", + "ti tt tt", + "ti ttrrr", + "tii", + "tii rttt", + "tiii", + "tiii tt", + "tiii trt", + "tiiii", + "tiiii ii", + "tiiii it", + "tiiii t", + "tiiii tt", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirt", + "tiiiirtt", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitir", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrti", + "tiiirrtr", + "tiiirrtt", + "tiiirt", + "tiiirtii", + "tiiirtit", + "tiiirtrr", + "tiiirtrt", + "tiiirtt", + "tiiirtti", + "tiiirttt", + "tiiit", + "tiiit t", + "tiiiti", + "tiiitiii", + "tiiitiit", + "tiiitirr", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrti", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiittii", + "tiiittit", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtt", + "tiirrt", + "tiirrt r", + "tiirrti", + "tiirrtii", + "tiirrtrr", + "tiirrttr", + "tiirrttt", + "tiirt rt", + "tiirti", + "tiirtiii", + "tiirtrrr", + "tiirtrrt", + "tiirtrtr", + "tiirtrtt", + "tiirtt", + "tiirttrr", + "tiirtttt", + "tiit", + "tiit tti", + "tiiti", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirr", + "tiitiirt", + "tiitiit", + "tiitiiti", + "tiitiitr", + "tiitiitt", + "tiitirrr", + "tiititi", + "tiititii", + "tiititit", + "tiititrr", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrtr", + "tiitrtrr", + "tiitrtrt", + "tiitrttt", + "tiitt", + "tiitti", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittirt", + "tiittiti", + "tiittitr", + "tiittitt", + "tiittrrr", + "tiittrt", + "tiittrti", + "tiittrtr", + "tiittrtt", + "tiittt", + "tiittt r", + "tiittt t", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtii", + "tirrrtir", + "tirrrtit", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrtti", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrt r", + "tirrt t", + "tirrtirr", + "tirrtirt", + "tirrtitr", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrttii", + "tirrttit", + "tirrttrr", + "tirrttrt", + "tirrttt", + "tirrttti", + "tirrtttt", + "tirt", + "tirt rtt", + "tirt t", + "tirt tit", + "tirt trt", + "tirti rr", + "tirtiiii", + "tirtiirr", + "tirtiitr", + "tirtirrr", + "tirtit", + "tirtitii", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrtit", + "tirtrtti", + "tirtrttt", + "tirtt", + "tirttiit", + "tirttrrr", + "tirttrtr", + "tirtttii", + "tirtttrr", + "tirtttti", + "tirttttt", + "tit", + "tit ii", + "tit iiii", + "tit itrt", + "tit rtt", + "tit ttii", + "titi", + "titii", + "titiii", + "titiiiii", + "titiiiit", + "titiiirr", + "titiiiti", + "titiiitt", + "titiirrr", + "titiit", + "titiitii", + "titiitit", + "titiitrr", + "titiitti", + "titiittt", + "titirrrr", + "titirrtt", + "titirt t", + "titirtir", + "titirtrt", + "titit", + "titit ii", + "titit tr", + "tititi", + "tititiii", + "tititiit", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititt", + "tititt t", + "titittii", + "titittit", + "titittrr", + "titittt", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrtii", + "titrrtit", + "titrrtrr", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrtiit", + "titrtrrr", + "titrtrrt", + "titrtrtr", + "titrtrtt", + "titrttii", + "titrttit", + "titrttrr", + "titrttt", + "titrttti", + "titrtttr", + "titrtttt", + "titt", + "titt rrr", + "titt rrt", + "titt ttt", + "titti", + "tittiiii", + "tittiiit", + "tittiirt", + "tittiit", + "tittiiti", + "tittiitt", + "tittirrr", + "tittirrt", + "tittit", + "tittiti", + "tittitii", + "tittitit", + "tittitrt", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrt", + "tittrrti", + "tittrrtr", + "tittrrtt", + "tittrtrr", + "tittrttt", + "tittt", + "tittti", + "titttiii", + "titttiir", + "titttiit", + "titttirr", + "titttiti", + "titttitr", + "titttitt", + "titttrrt", + "titttrt", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt t", + "trrrt rr", + "trrrt rt", + "trrrt t", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtit", + "trrrtitr", + "trrrtitt", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt ii", + "trrt rr", + "trrt irr", + "trrt irt", + "trrt rrr", + "trrt rrt", + "trrt rtr", + "trrt rtt", + "trrt t", + "trrt trr", + "trrt trt", + "trrt tt", + "trrt tti", + "trrt ttt", + "trrti", + "trrtii", + "trrtiii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirr", + "trrtiiti", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirt", + "trrtirtt", + "trrtit", + "trrtitit", + "trrtitrr", + "trrtitrt", + "trrtitti", + "trrtittr", + "trrtittt", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrt t", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt it", + "trrtt rr", + "trrtt rt", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrttiir", + "trrttiit", + "trrttirr", + "trrttit", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrttt t", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt t", + "trt ii", + "trt rr", + "trt tt", + "trt irr", + "trt rrr", + "trt t", + "trt trr", + "trt tt", + "trt rrrr", + "trt rrrt", + "trt rrt", + "trt rrtr", + "trt rrtt", + "trt rtrr", + "trt rttt", + "trt t", + "trt t rr", + "trt t tr", + "trt trrr", + "trt trrt", + "trt trt", + "trt trtr", + "trt trtt", + "trt ttrt", + "trt ttt", + "trt tttr", + "trt tttt", + "trti", + "trti ttt", + "trtii", + "trtiii", + "trtiiiii", + "trtiiirr", + "trtiiit", + "trtiiiti", + "trtiitii", + "trtiitrr", + "trtiitrt", + "trtirrrr", + "trtirrrt", + "trtirrtr", + "trtirrtt", + "trtirtii", + "trtirtir", + "trtirtrt", + "trtirttr", + "trtirttt", + "trtit", + "trtitiii", + "trtitiir", + "trtitrrr", + "trtitrrt", + "trtitrtr", + "trtitrtt", + "trtitt t", + "trtittit", + "trtittti", + "trtitttr", + "trtitttt", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrti", + "trtrrtii", + "trtrrtit", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt rr", + "trtrt rt", + "trtrt t", + "trtrt tr", + "trtrt tt", + "trtrti", + "trtrtii", + "trtrtirr", + "trtrtirt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtt t", + "trtrtti", + "trtrttii", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt i", + "trtt rr", + "trtt i", + "trtt iti", + "trtt rrr", + "trtt rrt", + "trtt rtr", + "trtt rtt", + "trtt t", + "trtt trr", + "trtt trt", + "trtt tt", + "trtt tti", + "trtt ttr", + "trtt ttt", + "trtti", + "trtti t", + "trttii", + "trttiii", + "trttiiii", + "trttiiir", + "trttiirr", + "trttiitr", + "trttiitt", + "trttirrr", + "trttirrt", + "trttirtt", + "trttitii", + "trttitrr", + "trttitrt", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt t", + "trttrtii", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt t", + "trttt rr", + "trttt rt", + "trttt t", + "trttt tr", + "trttt tt", + "trttti", + "trtttii", + "trtttiii", + "trtttiir", + "trtttiit", + "trtttirr", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt r", + "tt t", + "tt ii", + "tt rr", + "tt irr", + "tt irt", + "tt tii", + "tt trr", + "tt trt", + "tt tt", + "tt ttt", + "tt i", + "tt iiit", + "tt iitr", + "tt itrt", + "tt rrrr", + "tt rrtt", + "tt rtrt", + "tt rttt", + "tt t r", + "tt t t", + "tt trrr", + "tt trtr", + "tt ttii", + "tt ttrr", + "tt ttrt", + "tt ttt", + "tt tttt", + "tt i", + "tt ii", + "tt iiiii", + "tt iirtt", + "tt iittr", + "tt irrrr", + "tt irrt", + "tt it r", + "tt itiit", + "tt itrrr", + "tt rrrrr", + "tt rrrt", + "tt rrrtr", + "tt rrrtt", + "tt rrt", + "tt rrtrr", + "tt rrtti", + "tt rrttr", + "tt rt", + "tt rt rr", + "tt rtrrr", + "tt rtrrt", + "tt rtrt", + "tt rtrtt", + "tt rtt", + "tt rttrt", + "tt rtttr", + "tt rtttt", + "tt t", + "tt t rrt", + "tt t rtt", + "tt t tii", + "tt tittt", + "tt trrrr", + "tt trrrt", + "tt trrtr", + "tt trrtt", + "tt trtrr", + "tt trtrt", + "tt trttr", + "tt trttt", + "tt tt", + "tt tt rr", + "tt tt t", + "tt ttirt", + "tt ttitt", + "tt ttrrr", + "tt ttrrt", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt tttii", + "tt tttrr", + "tt tttrt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti iiit", + "tti tttt", + "ttii", + "ttii iii", + "ttii trr", + "ttii tti", + "ttiii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirt", + "ttiiirti", + "ttiiit", + "ttiiiti", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtt", + "ttiirtii", + "ttiirtrr", + "ttiit", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrt", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrti", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrtit", + "ttirrtrr", + "ttirrtti", + "ttirrttt", + "ttirt", + "ttirti", + "ttirtiii", + "ttirtit", + "ttirtrrr", + "ttirtrrt", + "ttirtrt", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttii", + "ttirttit", + "ttirttrr", + "ttirttrt", + "ttirttti", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit iii", + "ttit itt", + "ttit ttt", + "ttiti", + "ttitii", + "ttitiiii", + "ttitiiir", + "ttitiiit", + "ttitiirr", + "ttitiirt", + "ttitiit", + "ttitiiti", + "ttitiitr", + "ttitiitt", + "ttitirrr", + "ttitirti", + "ttitit", + "ttititii", + "ttititir", + "ttititit", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtir", + "ttitrtit", + "ttitrtrr", + "ttitrtrt", + "ttitrtti", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt t", + "ttitt tt", + "ttitti", + "ttitti t", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt ii", + "ttrrt rr", + "ttrrt rt", + "ttrrt t", + "ttrrt tr", + "ttrrt tt", + "ttrrti", + "ttrrtii", + "ttrrtiii", + "ttrrtiir", + "ttrrtiit", + "ttrrtirr", + "ttrrtitr", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrtti", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt t", + "ttrt rr", + "ttrt t", + "ttrt tt", + "ttrt rrr", + "ttrt rrt", + "ttrt rtr", + "ttrt rtt", + "ttrt trr", + "ttrt trt", + "ttrt ttr", + "ttrt ttt", + "ttrti", + "ttrti it", + "ttrtiii", + "ttrtiiit", + "ttrtiirt", + "ttrtiitt", + "ttrtirrr", + "ttrtirtr", + "ttrtirtt", + "ttrtit", + "ttrtitti", + "ttrtittr", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrtii", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt it", + "ttrtt rr", + "ttrtt tt", + "ttrtti", + "ttrttii", + "ttrttiii", + "ttrttiit", + "ttrttirr", + "ttrttirt", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrttti", + "ttrtttii", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt t", + "ttt ii", + "ttt rt", + "ttt t", + "ttt ti", + "ttt tr", + "ttt tt", + "ttt iii", + "ttt it", + "ttt rrr", + "ttt rrt", + "ttt rtt", + "ttt t", + "ttt t t", + "ttt trt", + "ttt tt", + "ttt ttt", + "ttt it", + "ttt itt", + "ttt ittt", + "ttt rrrr", + "ttt rrrt", + "ttt rt", + "ttt rtrr", + "ttt rtrt", + "ttt rtt", + "ttt rttr", + "ttt rttt", + "ttt t", + "ttt t r", + "ttt t rt", + "ttt tiii", + "ttt titt", + "ttt trrr", + "ttt trrt", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt tt t", + "ttt tti", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt ttti", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti tt", + "tttii", + "tttii i", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirt", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiit r", + "tttiiti", + "tttiitii", + "tttiitir", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrti", + "tttirrtr", + "tttirrtt", + "tttirtii", + "tttirtir", + "tttirtit", + "tttirtrr", + "tttirtrt", + "tttirtt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit tt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirr", + "tttitirt", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrirrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrti", + "tttrrtii", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt r", + "tttrt ii", + "tttrt ir", + "tttrt rr", + "tttrt rt", + "tttrt tr", + "tttrt tt", + "tttrtiii", + "tttrtirr", + "tttrtirt", + "tttrtit", + "tttrtiti", + "tttrtitr", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt r", + "tttrtt t", + "tttrtti", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt t", + "tttt ii", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt irr", + "tttt iti", + "tttt itt", + "tttt rrr", + "tttt rrt", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt t t", + "tttt ti", + "tttt tii", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti i", + "ttttii", + "ttttii t", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirti", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttit i", + "ttttit r", + "ttttit t", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtii", + "ttttrtir", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt ii", + "ttttt ir", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr21": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i r", + "i i", + "i ii", + "i r", + "i t", + "i iiiii", + "i tiiii", + "i i", + "i ii", + "i iiiii", + "i iiiiii", + "i iiiitt", + "i iiirrr", + "i iiittt", + "i itrrrt", + "i rtrrtr", + "i rttttt", + "i t", + "i tttiii", + "i tttr", + "ii", + "ii i", + "ii r", + "ii t", + "ii ii", + "ii tti", + "ii trtt", + "ii tttt", + "ii i", + "ii i ti", + "ii ii", + "ii iii", + "ii iiii", + "ii iiiii", + "ii iiit", + "ii ittt", + "ii t", + "ii t rrr", + "ii tii", + "ii tiiii", + "ii tti", + "ii ttrtt", + "ii ttttt", + "iii", + "iii i", + "iii i", + "iii ii", + "iii rrr", + "iii iii", + "iii iiii", + "iii iiti", + "iii rrti", + "iii t", + "iii tiii", + "iii tttr", + "iiii", + "iiii i", + "iiii ii", + "iiii iii", + "iiii ttt", + "iiiii", + "iiiii t", + "iiiii ii", + "iiiii it", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirr", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiit i", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitr", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirirr", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirti", + "iiiirtii", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirtti", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiitirr", + "iiiitirt", + "iiiitit", + "iiiititi", + "iiiititr", + "iiiititt", + "iiiitrr", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitt t", + "iiiittii", + "iiiittir", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtit", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrtti", + "iiirrttr", + "iiirt", + "iiirti", + "iiirtiii", + "iiirtiit", + "iiirtitr", + "iiirtrrr", + "iiirtrt", + "iiirtt", + "iiirttt", + "iiirtttt", + "iiit", + "iiit rrr", + "iiit ttt", + "iiiti", + "iiitii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiirt", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitirrr", + "iiitirtt", + "iiititii", + "iiititit", + "iiititt", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrtii", + "iiitrtrr", + "iiitrtrt", + "iiitrtt", + "iiitrtti", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitti", + "iiittiii", + "iiittiit", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirr", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrt r", + "iirrrtii", + "iirrrtrr", + "iirrrtrt", + "iirrrtt", + "iirrrtti", + "iirrt", + "iirrtii", + "iirrtiii", + "iirrtiit", + "iirrtrrt", + "iirrtrt", + "iirrtrtr", + "iirrtrtt", + "iirrtt", + "iirrttii", + "iirrttrr", + "iirrtttr", + "iirrtttt", + "iirt", + "iirti", + "iirtiiii", + "iirtiirr", + "iirtiitt", + "iirtirrt", + "iirtirtr", + "iirtit", + "iirtitrt", + "iirtrrrr", + "iirtrrrt", + "iirtrrtr", + "iirtrrtt", + "iirtrt", + "iirtrtrr", + "iirtrtrt", + "iirtrtti", + "iirtt", + "iirttiii", + "iirttit", + "iirttiti", + "iirttrtt", + "iirtttrr", + "iirtttrt", + "iirtttti", + "iirttttr", + "iirttttt", + "iit", + "iit iiit", + "iit tiii", + "iit tiit", + "iit ttit", + "iit tttt", + "iiti", + "iitii", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiir", + "iitiiiit", + "iitiiitr", + "iitiiitt", + "iitiirrr", + "iitiirti", + "iitiit", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitrt", + "iitiittt", + "iitirrti", + "iitit", + "iititi", + "iititiii", + "iititiit", + "iitititi", + "iitititt", + "iititrrr", + "iititt", + "iitittii", + "iitittir", + "iitittit", + "iitittrt", + "iitittti", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrt", + "iitrrrti", + "iitrrrtt", + "iitrrtii", + "iitrrtit", + "iitrrtrt", + "iitrrtti", + "iitrrttr", + "iitrt", + "iitrtrr", + "iitrtrrr", + "iitrtrrt", + "iitrtrt", + "iitrtrtr", + "iitrtrtt", + "iitrtt", + "iitrtti", + "iitrttrr", + "iitrttrt", + "iitrtttr", + "iitrtttt", + "iitt", + "iitti", + "iittiii", + "iittiiii", + "iittiiit", + "iittiirr", + "iittiirt", + "iittiit", + "iittiiti", + "iittiitt", + "iittirtr", + "iittitii", + "iittitit", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrt", + "iittrrti", + "iittrrtt", + "iittrtrr", + "iittrtrt", + "iittrtti", + "iittrttr", + "iittrttt", + "iittt", + "iitttiii", + "iitttiir", + "iitttiit", + "iitttirt", + "iitttit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrt", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttit", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irr", + "irrrr", + "irrrrr", + "irrrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrti", + "irrrrtii", + "irrrrtit", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrtti", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrtiii", + "irrrtiit", + "irrrtitr", + "irrrtrrr", + "irrrtrrt", + "irrrtrtr", + "irrrtrtt", + "irrrtt", + "irrrttii", + "irrrttrt", + "irrrttt", + "irrrtttt", + "irrt", + "irrtiiii", + "irrtitt", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrtr", + "irrtrrtt", + "irrtrt", + "irrtrtrr", + "irrtrtt", + "irrtrttr", + "irrtt", + "irrttiti", + "irrttt", + "irrttti", + "irrtttii", + "irrtttir", + "irrtttrr", + "irrtttrt", + "irrttttr", + "irrttttt", + "irt", + "irti", + "irtii", + "irtiiiit", + "irtiiirr", + "irtiiitt", + "irtiit", + "irtiitir", + "irtiittr", + "irtirrrr", + "irtirrrt", + "irtirt", + "irtirtit", + "irtitiii", + "irtittrr", + "irtrrrrr", + "irtrrrrt", + "irtrrrtr", + "irtrrrtt", + "irtrrt", + "irtrrtrt", + "irtrrtt", + "irtrrtti", + "irtrrttt", + "irtrt", + "irtrtiii", + "irtrtit", + "irtrtr", + "irtrtrrr", + "irtrttrr", + "irtrttrt", + "irtrttti", + "irtrtttr", + "irtt", + "irtti", + "irttiiii", + "irttiiit", + "irttirrt", + "irttittt", + "irttrrrr", + "irttrrtr", + "irttrrtt", + "irttrttr", + "irttt", + "irtttiii", + "irtttiit", + "irtttrrr", + "irtttrtt", + "irtttt", + "irtttti", + "irttttii", + "irttttir", + "irttttt", + "irtttttr", + "irtttttt", + "it", + "it rrrr", + "it trti", + "it iiiii", + "it iiiti", + "it rrtrr", + "it rrttr", + "it ttiii", + "it tttt", + "it ttttt", + "iti", + "iti trrt", + "iti tt", + "itii", + "itiii", + "itiiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiirt", + "itiiiit", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiirrr", + "itiiirt", + "itiiit", + "itiiiti", + "itiiitii", + "itiiitit", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirrt", + "itiit", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiitrrt", + "itiitrtt", + "itiitt", + "itiittii", + "itiittit", + "itiittti", + "itiitttt", + "itirrrrr", + "itirrtit", + "itirrtrr", + "itirrtrt", + "itirrttt", + "itirt", + "itirtitt", + "itirtrrr", + "itirtttt", + "itit", + "ititi", + "ititiii", + "ititiiii", + "ititiiit", + "ititiitt", + "ititirrr", + "ititirtt", + "ititit", + "itititi", + "itititii", + "itititit", + "itititrr", + "itititt", + "itititti", + "ititittt", + "ititrrrr", + "ititrrt", + "ititrrtt", + "ititrtti", + "ititrttr", + "ititrttt", + "ititt", + "ititti", + "itittiii", + "itittit", + "itittitr", + "itittrrr", + "itittrrt", + "itittrt", + "itittrtt", + "itittt", + "ititttii", + "ititttit", + "ititttrt", + "ititttt", + "ititttti", + "itittttr", + "itittttt", + "itrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrtit", + "itrrrtrr", + "itrrrtrt", + "itrrrtt", + "itrrrttt", + "itrrt", + "itrrtii", + "itrrtiii", + "itrrtrrr", + "itrrtrrt", + "itrrtrtt", + "itrrtti", + "itrrttii", + "itrrttit", + "itrrttrr", + "itrrttrt", + "itrrttt", + "itrrttti", + "itrrtttr", + "itrrtttt", + "itrt", + "itrti", + "itrtiitt", + "itrtirrr", + "itrtirt", + "itrtirtt", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrrtt", + "itrtrtrt", + "itrtrtt", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrttirt", + "itrttrrr", + "itrttrrt", + "itrttrtt", + "itrtttit", + "itrtttrt", + "itrtttti", + "itrttttt", + "itt", + "itt t", + "itt iiii", + "itt rrrt", + "itt tt", + "itti", + "itti tt", + "ittii", + "ittiii", + "ittiiiii", + "ittiiiir", + "ittiiiit", + "ittiiit", + "ittiiiti", + "ittiiitt", + "ittiit", + "ittiitii", + "ittiitit", + "ittiitrr", + "ittiitt", + "ittiitti", + "ittiittt", + "ittirrtr", + "ittirtrr", + "ittirttr", + "ittit", + "ittitiii", + "ittitiit", + "ittititi", + "ittititr", + "ittititt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittt", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrtrr", + "ittrrtrt", + "ittrrtti", + "ittrrttt", + "ittrt", + "ittrtrrr", + "ittrtrrt", + "ittrtrtr", + "ittrttit", + "ittrttrt", + "ittrtttt", + "ittt", + "ittt t", + "ittt rrt", + "ittti", + "itttii", + "itttiiii", + "itttiiit", + "itttiirr", + "itttiit", + "itttiiti", + "itttiitt", + "itttirti", + "itttirtt", + "itttit", + "itttitii", + "itttitit", + "itttitrt", + "itttitt", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrt", + "itttrrtt", + "itttrtrr", + "itttrtrt", + "itttrttr", + "itttrttt", + "itttt", + "itttt tt", + "itttti", + "ittttiii", + "ittttiit", + "ittttirt", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rittrttt", + "rr", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt t", + "rrrt rr", + "rrrt t", + "rrrt tr", + "rrrt r", + "rrrt rrr", + "rrrt rrt", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt trr", + "rrrt ttr", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitr", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt rr", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrr", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt rrr", + "rrt rrt", + "rrt rtt", + "rrt trr", + "rrt trt", + "rrt irrr", + "rrt rr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rti", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt t", + "rrt t t", + "rrt trrr", + "rrt trrt", + "rrt trtr", + "rrt trtt", + "rrt tt t", + "rrt ttit", + "rrt ttrr", + "rrt ttrt", + "rrti", + "rrtii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiiti", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitii", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiitti", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirtii", + "rrtirtir", + "rrtirtit", + "rrtirtrr", + "rrtirtt", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitiii", + "rrtitiir", + "rrtitirt", + "rrtitit", + "rrtititi", + "rrtititr", + "rrtititt", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtittii", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtr", + "rrtrrr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt t", + "rrtrt rr", + "rrtrt t", + "rrtrt tr", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtiti", + "rrtrtitt", + "rrtrtrr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttr", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt t", + "rrtt rrr", + "rrtt rrt", + "rrtt rtr", + "rrtt t", + "rrtt trr", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttiiii", + "rrttiiit", + "rrttiirr", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttittr", + "rrttittt", + "rrttr", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt r", + "rrttt ii", + "rrttt rr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrr", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt i", + "rt r", + "rt t", + "rt rrr", + "rt t", + "rt trr", + "rt trt", + "rt tt", + "rt iirr", + "rt rr", + "rt rrrr", + "rt rrrt", + "rt rrt", + "rt rrtr", + "rt rti", + "rt rtt", + "rt t", + "rt t t", + "rt tit", + "rt trrr", + "rt trrt", + "rt trt", + "rt trtr", + "rt trtt", + "rt tt", + "rt ttrr", + "rt tttr", + "rt i", + "rt iiiii", + "rt iiitt", + "rt rrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrt r", + "rt rrtii", + "rt rrtrr", + "rt rrtt", + "rt rrttt", + "rt rt", + "rt rtrrr", + "rt rtrt", + "rt rtrtr", + "rt rtrtt", + "rt rtt", + "rt rtt t", + "rt rtttt", + "rt t", + "rt t rrr", + "rt t tt", + "rt tiitr", + "rt trr", + "rt trrrr", + "rt trrrt", + "rt trrtr", + "rt trt", + "rt trtrr", + "rt trtrt", + "rt trttt", + "rt tt", + "rt tt rr", + "rt tt rt", + "rt ttrtt", + "rt ttt", + "rt ttttt", + "rti", + "rti t", + "rti rrrr", + "rti rrtt", + "rtii", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirti", + "rtiiirtt", + "rtiiit", + "rtiiitii", + "rtiiitir", + "rtiiitit", + "rtiiitrr", + "rtiiitrt", + "rtiiitt", + "rtiiitti", + "rtiiittr", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirrti", + "rtiirrtr", + "rtiirrtt", + "rtiirt", + "rtiirtii", + "rtiirtrt", + "rtiirtti", + "rtiit", + "rtiitiii", + "rtiitirr", + "rtiitirt", + "rtiititi", + "rtiititr", + "rtiitrrr", + "rtiitrrt", + "rtiitt", + "rtiittii", + "rtiittit", + "rtiittrr", + "rtiittrt", + "rtiitttt", + "rtirr", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtt", + "rtirrt", + "rtirrtii", + "rtirrtrr", + "rtirrtt", + "rtirrtti", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirti", + "rtirtirr", + "rtirtiti", + "rtirtitt", + "rtirtrrr", + "rtirtrrt", + "rtirtrti", + "rtirtrtr", + "rtirtrtt", + "rtirtt", + "rtirtt t", + "rtirttir", + "rtirttit", + "rtirttrr", + "rtirttrt", + "rtirtttr", + "rtirtttt", + "rtit", + "rtiti", + "rtitiiii", + "rtitiiit", + "rtitiirr", + "rtitiitt", + "rtitirrr", + "rtitirti", + "rtitirtr", + "rtitirtt", + "rtitit", + "rtititi", + "rtititit", + "rtititrr", + "rtititrt", + "rtititt", + "rtitittt", + "rtitrrrr", + "rtitrrrt", + "rtitrrti", + "rtitrt", + "rtitrtii", + "rtitrtrr", + "rtitrttr", + "rtitrttt", + "rtitt", + "rtitt tt", + "rtittiii", + "rtittrrr", + "rtittrrt", + "rtittrtt", + "rtittt", + "rtitttii", + "rtitttrt", + "rtitttt", + "rtittttr", + "rtittttt", + "rtr", + "rtrr", + "rtrrrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitr", + "rtrrtitt", + "rtrrtr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttr", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt rr", + "rtrt tr", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rtt", + "rtrt t", + "rtrt trr", + "rtrt trt", + "rtrt tt", + "rtrt tti", + "rtrti", + "rtrtii", + "rtrtiiii", + "rtrtiiit", + "rtrtiirr", + "rtrtiirt", + "rtrtiiti", + "rtrtiitr", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirtr", + "rtrtit", + "rtrtitii", + "rtrtitit", + "rtrtitrr", + "rtrtitt", + "rtrtittr", + "rtrtittt", + "rtrtrr", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtr", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt t", + "rtrtt rr", + "rtrtt t", + "rtrtt tt", + "rtrtti", + "rtrtti r", + "rtrttii", + "rtrttiii", + "rtrttiit", + "rtrttirr", + "rtrttirt", + "rtrttit", + "rtrttiti", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt tr", + "rtt trt", + "rtt tt", + "rtt ttt", + "rtt ii", + "rtt iiii", + "rtt rrrt", + "rtt rrtr", + "rtt rrtt", + "rtt rt", + "rtt rtrr", + "rtt rttr", + "rtt rttt", + "rtt trrr", + "rtt trrt", + "rtt trtr", + "rtt trtt", + "rtt ttt", + "rtt tttt", + "rtti", + "rttii", + "rttii r", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiit", + "rttiiirr", + "rttiiit", + "rttiiiti", + "rttiiitr", + "rttiirrr", + "rttiirrt", + "rttiit", + "rttiitrt", + "rttiitti", + "rttiittt", + "rttirrr", + "rttirrrr", + "rttirrrt", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtii", + "rttirtit", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirttt", + "rttit", + "rttitiit", + "rttitirt", + "rttititi", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttitti", + "rttittii", + "rttittrr", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrr", + "rttrrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrti", + "rttrrtii", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt t", + "rttrt rt", + "rttrt tt", + "rttrti", + "rttrtiii", + "rttrtiit", + "rttrtiti", + "rttrtitr", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt t", + "rttrttii", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt rr", + "rttt rrt", + "rttt rtt", + "rttt tt", + "rttt ttr", + "rttt ttt", + "rttti", + "rtttii", + "rtttiiii", + "rtttiiit", + "rtttiirt", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrr", + "rtttrrr", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrt t", + "rtttrti", + "rtttrtii", + "rtttrtir", + "rtttrtr", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt i", + "rtttt r", + "rtttt t", + "rtttt rr", + "rtttt t", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttir", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrr", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t i", + "t r", + "t t", + "t i", + "t ii", + "t it", + "t r", + "t rr", + "t rt", + "t t", + "t ti", + "t tr", + "t tt", + "t rrr", + "t t", + "t trr", + "t rrrr", + "t rrt", + "t rttt", + "t t", + "t t t", + "t tr", + "t trr", + "t trtt", + "t tt", + "t iiii", + "t it", + "t rr", + "t rrrr", + "t rrrrr", + "t rrrt", + "t rrrtr", + "t rrt", + "t rrti", + "t rrtr", + "t rrtrr", + "t rrtt", + "t rrttt", + "t rt", + "t rt rt", + "t rtii", + "t rtrt", + "t rtrtr", + "t rtrtt", + "t rtt", + "t rtttr", + "t t", + "t t r", + "t t rr", + "t t t", + "t t tr", + "t t trr", + "t ti", + "t trrr", + "t trrrr", + "t trrrt", + "t trrti", + "t trrtr", + "t trt", + "t trtrr", + "t trtrt", + "t trtt", + "t trtti", + "t tt tt", + "t tti", + "t ttit", + "t ttitr", + "t ttt", + "t tttt", + "t ttttt", + "t i", + "t iiii", + "t iiirrr", + "t irrrrr", + "t irt", + "t irtt", + "t it", + "t itii", + "t ittrtr", + "t ittttt", + "t rr", + "t rrrr", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrti", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrttt", + "t rrt", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrtr", + "t rrtt", + "t rrttii", + "t rrttir", + "t rrttrr", + "t rrtttt", + "t rt", + "t rt rt", + "t rt ttr", + "t rtiitt", + "t rtrrrr", + "t rtrrrt", + "t rtrrtt", + "t rtrti", + "t rtrtrr", + "t rtrtrt", + "t rtrtt", + "t rtrttr", + "t rtt", + "t rtt rr", + "t rtt tt", + "t rttrrr", + "t rttrrt", + "t rttt", + "t rttttt", + "t t", + "t t t", + "t t tt", + "t t rrr", + "t t rt", + "t t tt", + "t tiiiii", + "t tiiiir", + "t tirrrr", + "t tittt", + "t tr", + "t trrrr", + "t trrrrr", + "t trrrrt", + "t trrrtt", + "t trrt", + "t trrtrr", + "t trrtrt", + "t trrttr", + "t trrttt", + "t trt", + "t trtrrr", + "t trtrtt", + "t trtt", + "t trttii", + "t trttr", + "t trttti", + "t trtttt", + "t tt", + "t tt r", + "t tt rt", + "t tt rtt", + "t tt t t", + "t tt trr", + "t tt tt", + "t tt ttt", + "t tti", + "t ttiiit", + "t ttiitr", + "t ttitrr", + "t ttitti", + "t ttrrr", + "t ttrrrr", + "t ttrrt", + "t ttrrtr", + "t ttrt", + "t ttrtrr", + "t ttrtrt", + "t ttrtt", + "t ttrttr", + "t ttrttt", + "t ttt", + "t ttt t", + "t tttrr", + "t tttrrr", + "t tttt", + "t ttttii", + "t ttttit", + "t ttttt", + "t tttttt", + "ti", + "ti t t", + "ti t tt", + "ti iiti", + "ti tii", + "ti trrrr", + "ti trttt", + "ti tttrt", + "tii", + "tii ttt", + "tii itrt", + "tii ttii", + "tii tttt", + "tiii", + "tiiii", + "tiiii rt", + "tiiiii", + "tiiiii t", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirti", + "tiiiirtr", + "tiiiirtt", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittt", + "tiiir", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrti", + "tiiirrtr", + "tiiirrtt", + "tiiirt", + "tiiirtii", + "tiiirtit", + "tiiirtrr", + "tiiirtrt", + "tiiirtti", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitiii", + "tiiitiit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrti", + "tiiitrtr", + "tiiittii", + "tiiittir", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrtr", + "tiirrrtt", + "tiirrtii", + "tiirrtt", + "tiirrtti", + "tiirrttt", + "tiirt", + "tiirtiii", + "tiirtirr", + "tiirtrrt", + "tiirtrtr", + "tiirtt", + "tiirttrt", + "tiirttti", + "tiirtttr", + "tiirtttt", + "tiit", + "tiiti", + "tiitii", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirr", + "tiitiit", + "tiitiiti", + "tiitiitr", + "tiitiitt", + "tiitirrr", + "tiitirti", + "tiitirtr", + "tiitit", + "tiititi", + "tiititii", + "tiititit", + "tiititrr", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrt", + "tiitrt r", + "tiitrtrr", + "tiitrtrt", + "tiitrttr", + "tiitt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittit", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrt", + "tiittrtr", + "tiittt", + "tiittti", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirr", + "tirrrrr", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrti", + "tirrrtii", + "tirrrtir", + "tirrrtrr", + "tirrrtrt", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrt it", + "tirrtiii", + "tirrtit", + "tirrtitr", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrti", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrttii", + "tirrttit", + "tirrttti", + "tirrtttt", + "tirt", + "tirt t", + "tirti", + "tirtiiii", + "tirtiirr", + "tirtit", + "tirtitrr", + "tirtitrt", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrrtr", + "tirtrrtt", + "tirtrt", + "tirtrtrr", + "tirtrtrt", + "tirtrttt", + "tirtt", + "tirtti", + "tirttiii", + "tirttiit", + "tirttirt", + "tirttitt", + "tirttrrr", + "tirttt", + "tirtttit", + "tirtttrr", + "tirtttrt", + "tirtttt", + "tirtttti", + "tirttttr", + "tirttttt", + "tit", + "tit t", + "tit trrt", + "tit tttt", + "titi", + "titii", + "titiii", + "titiiiii", + "titiiiit", + "titiiirr", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirtt", + "titiit", + "titiitii", + "titiitit", + "titiitrr", + "titiitt", + "titiitti", + "titiittt", + "titirrrr", + "titirrrt", + "titirrt", + "titirt", + "titirtit", + "titirtrt", + "titirtt", + "titirttr", + "titit", + "tititi", + "tititiii", + "tititiit", + "titititi", + "titititr", + "titititt", + "tititrrt", + "tititt", + "tititti", + "titittii", + "titittir", + "titittit", + "titittt", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrtir", + "titrrtrr", + "titrrtrt", + "titrrtt", + "titrrttr", + "titrrttt", + "titrt", + "titrtirr", + "titrtiti", + "titrtrrr", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrttit", + "titrttrr", + "titrtttr", + "titrtttt", + "titt", + "titti", + "tittii", + "tittiii", + "tittiiii", + "tittiiit", + "tittiirr", + "tittiitt", + "tittirrr", + "tittirrt", + "tittit", + "tittitii", + "tittitit", + "tittitrt", + "tittitti", + "tittittr", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrt", + "tittrrtr", + "tittrrtt", + "tittrtii", + "tittrtrr", + "tittrtt", + "tittrttr", + "tittrttt", + "tittt", + "tittt tt", + "tittti", + "titttiii", + "titttiir", + "titttiit", + "titttirr", + "titttit", + "titttiti", + "titttitt", + "titttrrr", + "titttrrt", + "titttrtr", + "titttrtt", + "titttt", + "titttt t", + "titttti", + "tittttii", + "tittttir", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trr", + "trrr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt t", + "trrrt rr", + "trrrt rt", + "trrrti", + "trrrtiii", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtitr", + "trrrtitt", + "trrrtrr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt t", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt rr", + "trrt tr", + "trrt tt", + "trrt rrr", + "trrt t r", + "trrt trr", + "trrt tt", + "trrt ttt", + "trrti", + "trrtii", + "trrtiiii", + "trrtiiit", + "trrtiirt", + "trrtiiti", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirti", + "trrtirtt", + "trrtit", + "trrtiti", + "trrtitii", + "trrtitrr", + "trrtitrt", + "trrtitt", + "trrtitti", + "trrtittr", + "trrtittt", + "trrtr", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtr", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt rr", + "trrtt t", + "trrtt tr", + "trrtti", + "trrttiii", + "trrttiir", + "trrttirr", + "trrttirt", + "trrttitr", + "trrttitt", + "trrttrr", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttti", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt t", + "trt rrt", + "trt tr", + "trt trr", + "trt trt", + "trt tt", + "trt rrrr", + "trt rrrt", + "trt rrt", + "trt rrtt", + "trt rt", + "trt rtrr", + "trt rtrt", + "trt rttr", + "trt t", + "trt t tr", + "trt trrr", + "trt trrt", + "trt trt", + "trt trtt", + "trt tt", + "trt tttr", + "trti", + "trtii", + "trtiii", + "trtiiiii", + "trtiiiir", + "trtiiiit", + "trtiiirr", + "trtiiitr", + "trtiiitt", + "trtiirrr", + "trtiirrt", + "trtiirti", + "trtiirtt", + "trtiiti", + "trtiitir", + "trtiitit", + "trtiitti", + "trtirrrr", + "trtirrrt", + "trtirrtr", + "trtirrtt", + "trtirt", + "trtirttt", + "trtit", + "trtitiii", + "trtitiit", + "trtitit", + "trtitrrr", + "trtitrrt", + "trtitrti", + "trtitrtt", + "trtitt", + "trtitt r", + "trtittii", + "trtittrr", + "trtittrt", + "trtittti", + "trtitttt", + "trtr", + "trtrrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrti", + "trtrrtii", + "trtrrtir", + "trtrrtit", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt tt", + "trtrti", + "trtrtiii", + "trtrtirr", + "trtrtirt", + "trtrtiti", + "trtrtitt", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt t", + "trtrtti", + "trtrttii", + "trtrttir", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt ii", + "trtt t", + "trtt tr", + "trtt ttr", + "trtt ttt", + "trtti", + "trttii", + "trttiii", + "trttiiii", + "trttiiit", + "trttiirr", + "trttiirt", + "trttiiti", + "trttiitt", + "trttirrr", + "trttirrt", + "trttirti", + "trttirtr", + "trttit", + "trttitit", + "trttitrr", + "trttitrt", + "trttitt", + "trttitti", + "trttittr", + "trttittt", + "trttrr", + "trttrrr", + "trttrrrr", + "trttrrrt", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrti", + "trttrtir", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt tt", + "trttti", + "trtttiii", + "trtttirr", + "trtttirt", + "trtttit", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttr", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt r", + "tt t", + "tt rr", + "tt rt", + "tt tt", + "tt iii", + "tt rrr", + "tt t", + "tt trr", + "tt iii", + "tt irtt", + "tt rrr", + "tt rrrr", + "tt rrrt", + "tt trt", + "tt trtr", + "tt trtt", + "tt tt", + "tt ttrt", + "tt ttt", + "tt tttt", + "tt ii", + "tt ittrr", + "tt rrrrt", + "tt rrrti", + "tt rrt", + "tt rrtit", + "tt rrtrr", + "tt rrtrt", + "tt rrttr", + "tt rrttt", + "tt rt rt", + "tt rt tr", + "tt rtrrr", + "tt rtrtr", + "tt rtrtt", + "tt rtttt", + "tt t", + "tt t rr", + "tt t rt", + "tt t tt", + "tt t rrr", + "tt ti", + "tt ti i", + "tt trrrr", + "tt trrt", + "tt trtrr", + "tt trttt", + "tt tt", + "tt tt r", + "tt tt it", + "tt tt t", + "tt tt tr", + "tt ttiii", + "tt ttitt", + "tt ttrrr", + "tt ttrti", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt tttii", + "tt tttrr", + "tt tttrt", + "tt ttttr", + "tt ttttt", + "tti", + "tti tti", + "tti ttt", + "tti titi", + "tti ttrt", + "ttii", + "ttii ttt", + "ttiii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtt", + "ttiiit", + "ttiiit i", + "ttiiiti", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrti", + "ttiirrtr", + "ttiirrtt", + "ttiirt", + "ttiirti", + "ttiirtii", + "ttiirtrr", + "ttiirtrt", + "ttiirtt", + "ttiirtti", + "ttiirttt", + "ttiit", + "ttiit t", + "ttiiti", + "ttiitiii", + "ttiitiit", + "ttiitirr", + "ttiitirt", + "ttiitit", + "ttiititi", + "ttiititr", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrt", + "ttiitrti", + "ttiitrtt", + "ttiitt", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrr", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrtr", + "ttirrt", + "ttirrtii", + "ttirrtrr", + "ttirrttr", + "ttirrttt", + "ttirt", + "ttirtiit", + "ttirtitt", + "ttirtrrt", + "ttirtrti", + "ttirtrtr", + "ttirtt", + "ttirttii", + "ttirttti", + "ttirtttt", + "ttit", + "ttit t", + "ttit ttt", + "ttiti", + "ttiti it", + "ttitii", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiiti", + "ttitiitr", + "ttitiitt", + "ttitirrr", + "ttitirrt", + "ttitit", + "ttititi", + "ttititii", + "ttititir", + "ttititit", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrt", + "ttitrrtt", + "ttitrt", + "ttitrtii", + "ttitrtit", + "ttitrtrr", + "ttitrtrt", + "ttitrtt", + "ttitrtti", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiir", + "ttittiit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttr", + "ttrrrr", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrti", + "ttrrtii", + "ttrrtiii", + "ttrrtiit", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtiti", + "ttrrtitr", + "ttrrtitt", + "ttrrtrr", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrtti", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt tr", + "ttrt ttt", + "ttrti", + "ttrtiii", + "ttrtiiii", + "ttrtiiir", + "ttrtiiit", + "ttrtiirr", + "ttrtiirt", + "ttrtiitt", + "ttrtirrr", + "ttrtirt", + "ttrtirtt", + "ttrtit", + "ttrtitir", + "ttrtitrr", + "ttrtitrt", + "ttrtitti", + "ttrtittr", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt t", + "ttrtrti", + "ttrtrtit", + "ttrtrtr", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt rr", + "ttrtt t", + "ttrtt tt", + "ttrtti", + "ttrttii", + "ttrttiii", + "ttrttiit", + "ttrttirr", + "ttrttirt", + "ttrttiti", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt t", + "ttrttti", + "ttrtttii", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt i", + "ttt tr", + "ttt iii", + "ttt rrr", + "ttt rrt", + "ttt rtr", + "ttt t t", + "ttt trr", + "ttt trt", + "ttt tt", + "ttt ttt", + "ttt ii", + "ttt iii", + "ttt rrrr", + "ttt rrtr", + "ttt rtrr", + "ttt t", + "ttt t r", + "ttt t tt", + "ttt ti", + "ttt tirr", + "ttt titt", + "ttt trrr", + "ttt trtt", + "ttt tt", + "ttt tt t", + "ttt ttii", + "ttt ttir", + "ttt ttrr", + "ttt ttt", + "ttt tttt", + "ttti", + "ttti tt", + "tttii", + "tttii ii", + "tttii tr", + "tttii tt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirti", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiit t", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrtt", + "tttirt", + "tttirtrr", + "tttirtrt", + "tttirtt", + "tttirttr", + "tttirttt", + "tttit", + "tttit tt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiir", + "tttitiit", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrti", + "tttrrtii", + "tttrrtir", + "tttrrtit", + "tttrrtr", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt t", + "tttrti", + "tttrtiii", + "tttrtiit", + "tttrtit", + "tttrtiti", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt t", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt t", + "tttt rr", + "tttt t", + "tttt tr", + "tttt tt", + "tttt rrr", + "tttt rrt", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt ti", + "tttt trt", + "tttt tt", + "tttt ttt", + "tttti", + "tttti ti", + "tttti tt", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttiti", + "ttttitii", + "ttttitir", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtir", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt i", + "ttttt ir", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti i", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrr", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr22": [ + "-1", + "-2", + "-6", + "i", + "i iiii", + "i iiit", + "i tttt", + "i iiii", + "i iiiii", + "i tiii", + "i tit", + "i trrt", + "i trtrr", + "i ttttt", + "i ii ti", + "i iii ii", + "i iiiii", + "i iiiiii", + "i iiiitt", + "i itiitt", + "i rrrrrr", + "i ttrrrr", + "i ttttrr", + "i ttttt", + "ii", + "ii i", + "ii iii", + "ii iiiii", + "ii iiitt", + "ii rrrtt", + "ii ttt", + "ii tttti", + "ii ttttt", + "iii", + "iii i", + "iii ii", + "iii iii", + "iii tit", + "iii tti", + "iii i", + "iii iii", + "iii iiii", + "iii irrr", + "iii itit", + "iii ittr", + "iii tt r", + "iii tti", + "iii tttt", + "iiii", + "iiii t", + "iiii ii", + "iiii it", + "iiii t", + "iiii iii", + "iiii t", + "iiii tii", + "iiii tt", + "iiii ttr", + "iiiii", + "iiiii i", + "iiiii ii", + "iiiii it", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiii r", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiir", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirr", + "iiiiirrr", + "iiiiirrt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitit", + "iiiiitr", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirtii", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirtti", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitirr", + "iiiitit", + "iiiititi", + "iiiititt", + "iiiitrr", + "iiiitrrr", + "iiiitrrt", + "iiiitrti", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrt r", + "iiirrtii", + "iiirrtrt", + "iiirrtt", + "iiirrttr", + "iiirrttt", + "iiirt", + "iiirtit", + "iiirtitt", + "iiirtrrr", + "iiirtrrt", + "iiirtrtr", + "iiirtrtt", + "iiirtt", + "iiirttii", + "iiirttr", + "iiirttrt", + "iiirtttt", + "iiit", + "iiiti", + "iiitii", + "iiitiii", + "iiitiiii", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitirrr", + "iiitirrt", + "iiitirti", + "iiitirtt", + "iiitit", + "iiititii", + "iiititit", + "iiititt", + "iiititti", + "iiitittr", + "iiitittt", + "iiitrr", + "iiitrrrr", + "iiitrrrt", + "iiitrrt", + "iiitrrti", + "iiitrrtr", + "iiitrtii", + "iiitrtrt", + "iiitrtti", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitti i", + "iiittii", + "iiittiii", + "iiittiit", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttir", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtii", + "iirrrtir", + "iirrrtrt", + "iirrrtti", + "iirrrttt", + "iirrt", + "iirrti", + "iirrtrrr", + "iirrtrrt", + "iirrtt", + "iirrttii", + "iirrttt", + "iirrtttr", + "iirrtttt", + "iirt", + "iirtiiii", + "iirtiiit", + "iirtirrr", + "iirtirrt", + "iirtit", + "iirtitii", + "iirtitti", + "iirtrrr", + "iirtrrrr", + "iirtrtir", + "iirtrtrr", + "iirtrtt", + "iirtrttr", + "iirtrttt", + "iirtt", + "iirttirt", + "iirttiti", + "iirttrrr", + "iirttrtr", + "iirttt", + "iirtttrr", + "iirtttt", + "iirttttr", + "iirttttt", + "iit", + "iit titt", + "iiti", + "iitii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiiti", + "iitiiitt", + "iitiirrr", + "iitiirrt", + "iitiirti", + "iitiirtt", + "iitiit", + "iitiiti", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrrr", + "iitirrtt", + "iitirtir", + "iitirtt", + "iitirtti", + "iitirttt", + "iitit", + "iititiii", + "iititiit", + "iitititi", + "iitititr", + "iitititt", + "iititrrr", + "iitittii", + "iitittit", + "iitittt", + "iitittti", + "iititttr", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrti", + "iitrrrtr", + "iitrrt", + "iitrrtrr", + "iitrrtrt", + "iitrrtt", + "iitrrttr", + "iitrrttt", + "iitrt", + "iitrtitr", + "iitrtitt", + "iitrtrrr", + "iitrtrrt", + "iitrtrti", + "iitrtrtt", + "iitrtt", + "iitrttii", + "iitrtttt", + "iitt", + "iitt ttt", + "iitti", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiit", + "iittiiti", + "iittiitr", + "iittiitt", + "iittit", + "iittitii", + "iittitit", + "iittitt", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrt", + "iittrtit", + "iittrtt", + "iittrttr", + "iittrttt", + "iittt", + "iittt t", + "iittt tt", + "iittti", + "iitttiii", + "iitttiit", + "iitttit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttt r", + "iittttii", + "iittttir", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "ir", + "irr", + "irrr", + "irrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrt r", + "irrrrti", + "irrrrtrr", + "irrrrtrt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrti", + "irrrtiit", + "irrrtrrr", + "irrrtrrt", + "irrrtrtr", + "irrrtrtt", + "irrrtt", + "irrrttit", + "irrrttrt", + "irrrttt", + "irrrtttt", + "irrt", + "irrti", + "irrtii", + "irrtiiii", + "irrtiitt", + "irrtirrr", + "irrtittr", + "irrtittt", + "irrtrrrr", + "irrtrrrt", + "irrtrrtr", + "irrtrrtt", + "irrtrt", + "irrtrtii", + "irrtrtrr", + "irrtrtt", + "irrtrttr", + "irrtrttt", + "irrtt", + "irrttrt", + "irrttrtr", + "irrtttrr", + "irrttttt", + "irt", + "irti", + "irtiiirr", + "irtiiiti", + "irtiirti", + "irtirrrt", + "irtititi", + "irtitrrr", + "irtitt", + "irtittii", + "irtittir", + "irtittit", + "irtittti", + "irtitttt", + "irtrrrrr", + "irtrrrrt", + "irtrrrt", + "irtrrrtr", + "irtrrrtt", + "irtrrtrt", + "irtrrttr", + "irtrtrt", + "irtrtrtt", + "irtrtt", + "irtrttir", + "irtrttrt", + "irtrtttr", + "irtrtttt", + "irtt", + "irttiiii", + "irttiiir", + "irttiiit", + "irttiit", + "irttirrr", + "irttirrt", + "irttitit", + "irttrrrr", + "irttrrrt", + "irttrrtt", + "irttt", + "irtttirt", + "irtttitt", + "irtttrrr", + "irtttrti", + "irtttt", + "irttttit", + "irttttrt", + "irttttti", + "irtttttt", + "it", + "it t", + "it ttttt", + "iti", + "iti trt", + "iti ti i", + "itii", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiit", + "itiiiirr", + "itiiiirt", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiirtt", + "itiiit", + "itiiiti", + "itiiitii", + "itiiitit", + "itiiitti", + "itiiittr", + "itiiittt", + "itiirrrr", + "itiirrrt", + "itiit", + "itiiti", + "itiitiii", + "itiitit", + "itiititt", + "itiitt", + "itiittii", + "itiittit", + "itiittti", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirrrt", + "itirrrti", + "itirrrtt", + "itirrtrr", + "itirt rr", + "itirtiti", + "itirtt", + "itirtti", + "itirttrr", + "itirtttt", + "itit", + "ititi", + "ititii", + "ititiii", + "ititiiii", + "ititiiit", + "ititiiti", + "ititiitt", + "ititirrr", + "ititirti", + "ititit", + "itititii", + "itititit", + "itititrr", + "itititt", + "itititti", + "ititrrrr", + "ititrrt", + "ititrrtt", + "ititrtit", + "ititt", + "ititti", + "itittiii", + "itittiit", + "itittitr", + "itittitt", + "itittt", + "ititttii", + "ititttit", + "ititttrt", + "ititttt", + "ititttti", + "itittttr", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrti", + "itrrrtir", + "itrrrtit", + "itrrrtrr", + "itrrrtrt", + "itrrrttt", + "itrrti", + "itrrtiii", + "itrrtt", + "itrrttrr", + "itrrttt", + "itrrtttr", + "itrrtttt", + "itrt", + "itrtirtt", + "itrtitit", + "itrtittt", + "itrtrrrr", + "itrtrrt", + "itrtrrtt", + "itrtrtir", + "itrtrtrr", + "itrtrtrt", + "itrtrtti", + "itrtrttr", + "itrtrttt", + "itrttrrr", + "itrttrti", + "itrtttii", + "itrtttir", + "itrtttrt", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt i", + "itt tttt", + "itti", + "itti t t", + "ittii", + "ittiii", + "ittiiii", + "ittiiiii", + "ittiiiit", + "ittiiit", + "ittiiiti", + "ittiiitr", + "ittiiitt", + "ittiit", + "ittiitii", + "ittiitir", + "ittiitt", + "ittiitti", + "ittiittr", + "ittiittt", + "ittirrrt", + "ittit", + "ittiti", + "ittitiii", + "ittitiit", + "ittititi", + "ittititt", + "ittitrtt", + "ittitt", + "ittitti", + "ittittii", + "ittittit", + "ittittrr", + "ittittt", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrti", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrt t", + "ittrrtrr", + "ittrrtrt", + "ittrrttr", + "ittrrttt", + "ittrtiii", + "ittrtirr", + "ittrtitt", + "ittrtrrr", + "ittrtrrt", + "ittrtrtt", + "ittrttrr", + "ittrttrt", + "ittrttt", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt tt", + "ittt ttt", + "ittti", + "itttiii", + "itttiiii", + "itttiiit", + "itttiit", + "itttiiti", + "itttiitt", + "itttirtt", + "itttit", + "itttitii", + "itttitit", + "itttitrt", + "itttitt", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrtir", + "itttrtrr", + "itttrtrt", + "itttrttr", + "itttrttt", + "itttt", + "itttt rr", + "itttti", + "ittttiii", + "ittttiit", + "ittttirr", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrti", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt t", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rr", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt it", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrti r", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttri", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt t", + "rrrt rr", + "rrrt t", + "rrrt tr", + "rrrt iii", + "rrrt iit", + "rrrt itr", + "rrrt rr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt tii", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt rr", + "rrrtt t", + "rrrtt tr", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrr", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt t", + "rrt tr", + "rrt irt", + "rrt rrr", + "rrt rrt", + "rrt t", + "rrt trr", + "rrt tt", + "rrt ttr", + "rrt i", + "rrt iitr", + "rrt itt", + "rrt rr", + "rrt rrr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rt", + "rrt rtrr", + "rrt rttt", + "rrt t", + "rrt t rr", + "rrt titt", + "rrt trrr", + "rrt trtt", + "rrt tt", + "rrt ttii", + "rrt ttrt", + "rrt ttt", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti i", + "rrtii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitii", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirtir", + "rrtirtrr", + "rrtirtt", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtitiii", + "rrtitirr", + "rrtitrrr", + "rrtitrrt", + "rrtitrti", + "rrtitrtt", + "rrtitt", + "rrtitti", + "rrtittii", + "rrtittrr", + "rrtittrt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt r", + "rrtrt t", + "rrtrt rr", + "rrtrt t", + "rrtrt tt", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt r", + "rrtt rr", + "rrtt rrr", + "rrtt t", + "rrtt trr", + "rrtt tt", + "rrtt tti", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiiti", + "rrttiitt", + "rrttir", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit t", + "rrttitii", + "rrttitir", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrtii", + "rrttrtit", + "rrttrtr", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt r", + "rrttt rr", + "rrttt rt", + "rrttt t", + "rrttt tt", + "rrttti", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrr", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt i", + "rt r", + "rt t", + "rt rr", + "rt rrrr", + "rt rtrr", + "rt t", + "rt t t", + "rt trrr", + "rt trtr", + "rt tt", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt r", + "rt rrtit", + "rt rrtrr", + "rt rrtt", + "rt rrttt", + "rt rt r", + "rt rt ii", + "rt rt rt", + "rt rtrrr", + "rt rtrtr", + "rt rtt", + "rt rtt r", + "rt rttt", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t t", + "rt trrrr", + "rt trrrt", + "rt trt t", + "rt trtrt", + "rt trtti", + "rt trttr", + "rt trttt", + "rt tt", + "rt ttiii", + "rt ttttt", + "rti", + "rti iiii", + "rti tttt", + "rtii", + "rtii iit", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitr", + "rtiiirrr", + "rtiiirtr", + "rtiiirtt", + "rtiiitir", + "rtiiitit", + "rtiiitrr", + "rtiiittr", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirt", + "rtiirtii", + "rtiirtrt", + "rtiirttt", + "rtiit", + "rtiitiii", + "rtiitiir", + "rtiitiit", + "rtiitirr", + "rtiititi", + "rtiitrrr", + "rtiitrti", + "rtiitrtt", + "rtiitt", + "rtiittii", + "rtiittit", + "rtiittrr", + "rtiittrt", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtii", + "rtirrtir", + "rtirrtit", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirtiii", + "rtirtirr", + "rtirtrrr", + "rtirtrtr", + "rtirtt", + "rtirttii", + "rtirttit", + "rtirttrr", + "rtirttt", + "rtirttti", + "rtirtttt", + "rtit", + "rtit itt", + "rtiti", + "rtitiiii", + "rtitiirr", + "rtitirrr", + "rtitirti", + "rtitit", + "rtititit", + "rtititrr", + "rtititt", + "rtitittt", + "rtitrrr", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtrr", + "rtitrtrt", + "rtitrtt", + "rtitt", + "rtitti", + "rtittiii", + "rtittiit", + "rtittirt", + "rtittrrr", + "rtittrrt", + "rtittrti", + "rtittrtr", + "rtittt", + "rtittti", + "rtitttii", + "rtitttrr", + "rtitttt", + "rtitttti", + "rtittttr", + "rtittttt", + "rtrr", + "rtrrrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt t", + "rtrrt t", + "rtrrti", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtitr", + "rtrrtitt", + "rtrrtr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt t", + "rtrt rt", + "rtrt tr", + "rtrt rr", + "rtrt rrr", + "rtrt rrt", + "rtrt rtr", + "rtrt rtt", + "rtrt trr", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiirr", + "rtrtiitt", + "rtrtirrr", + "rtrtirti", + "rtrtirtt", + "rtrtit", + "rtrtitrr", + "rtrtitt", + "rtrtitti", + "rtrtittt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrti", + "rtrtrtii", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt t", + "rtrtt rr", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttiir", + "rtrttiit", + "rtrttirt", + "rtrttit", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt r", + "rtt rr", + "rtt rrr", + "rtt rt", + "rtt t", + "rtt ttt", + "rtt iiii", + "rtt iirr", + "rtt rrrr", + "rtt rrrt", + "rtt rrti", + "rtt rttr", + "rtt rttt", + "rtt t", + "rtt trrt", + "rtt trtt", + "rtt ttit", + "rtt ttrr", + "rtt tttt", + "rtti", + "rtti rrr", + "rtti tit", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiirt", + "rttiiiti", + "rttiirrr", + "rttiirrt", + "rttiirt", + "rttiirtt", + "rttiit", + "rttiitii", + "rttiitir", + "rttiitit", + "rttiitrr", + "rttiitti", + "rttiittr", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirtit", + "rttirtrr", + "rttirtrt", + "rttirtti", + "rttirttt", + "rttit", + "rttit tt", + "rttitiii", + "rttitiir", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrtt", + "rttitt", + "rttittii", + "rttittir", + "rttittit", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt t", + "rttrt tr", + "rttrtiii", + "rttrtiit", + "rttrtirr", + "rttrtirt", + "rttrtiti", + "rttrtitr", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt r", + "rttrtti", + "rttrttir", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt t", + "rttt r", + "rttt tr", + "rttt r", + "rttt rrr", + "rttt rrt", + "rttt ttt", + "rttti", + "rtttiii", + "rtttiiii", + "rtttiiir", + "rtttiirr", + "rtttiiti", + "rtttirrr", + "rtttirrt", + "rtttirti", + "rtttirtr", + "rtttit", + "rtttitir", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittt", + "rtttrr", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrti", + "rtttrtii", + "rtttrtir", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt it", + "rtttt t", + "rtttt tr", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttr", + "rtttttri", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t i", + "t r", + "t irr", + "t rrt", + "t rt", + "t tr", + "t trr", + "t ttt", + "t rrrr", + "t rttt", + "t t", + "t trrr", + "t rrrr", + "t rrrrr", + "t rrrrt", + "t rrrtt", + "t rrt", + "t rrtrr", + "t rtrr", + "t rtrtr", + "t rtt", + "t t", + "t t t", + "t t t", + "t tiiir", + "t trr", + "t trrr", + "t trrrr", + "t trrrt", + "t trrtt", + "t trt", + "t trtrt", + "t trtt", + "t trttt", + "t tt", + "t ttrrt", + "t ttt", + "t tttt", + "t ttttt", + "t iii", + "t iiiiii", + "t iiitit", + "t ittrt", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrtr", + "t rrrrtt", + "t rrrtit", + "t rrrtrr", + "t rrrtt", + "t rrrttt", + "t rrt", + "t rrt rt", + "t rrtrr", + "t rrtrrr", + "t rrtrtr", + "t rrttit", + "t rrttrr", + "t rrttrt", + "t rrttt", + "t rrtttt", + "t rt", + "t rt tr", + "t rt rt", + "t rtiiii", + "t rtrrr", + "t rtrrrr", + "t rtt", + "t rtti", + "t rttrtr", + "t rttttt", + "t t", + "t t rrr", + "t t rtrt", + "t t t", + "t t trtr", + "t t tt t", + "t tiitrr", + "t titttr", + "t trrrrr", + "t trrrtr", + "t trrt", + "t trrtrt", + "t trt", + "t trtiir", + "t trtr", + "t trtrrr", + "t trtrtt", + "t trtt", + "t tt", + "t tt t", + "t tt t", + "t tt tt", + "t tt rt", + "t tt trr", + "t tt ttt", + "t tti tt", + "t ttiii", + "t ttiiii", + "t ttirrr", + "t ttitrt", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrtrt", + "t ttrtt", + "t ttt", + "t ttti", + "t tttiii", + "t tttitt", + "t tttrtr", + "t tttt", + "t ttttii", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti ttii", + "ti i", + "ti ii ti", + "ti rrrrr", + "ti rttt", + "ti t", + "ti trrrr", + "ti ttiit", + "ti ttttt", + "tii", + "tii iiir", + "tiii", + "tiii i", + "tiiii", + "tiiii tt", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirt", + "tiiiirti", + "tiiiit", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrt", + "tiiirrti", + "tiiirrtt", + "tiiirt", + "tiiirtit", + "tiiirtrr", + "tiiirtrt", + "tiiirtti", + "tiiit", + "tiiiti", + "tiiitiii", + "tiiitiir", + "tiiitiit", + "tiiitirr", + "tiiitirt", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrt", + "tiiitrtt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittt", + "tiiittti", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrrtt", + "tiirrtii", + "tiirrtit", + "tiirrtrr", + "tiirrtt", + "tiirrtti", + "tiirrttt", + "tiirtiii", + "tiirtiit", + "tiirtirt", + "tiirtit", + "tiirtitr", + "tiirtitt", + "tiirtrtt", + "tiirtt", + "tiirttir", + "tiirttit", + "tiirtttr", + "tiirtttt", + "tiit", + "tiit ttt", + "tiiti", + "tiitii", + "tiitiiii", + "tiitiiir", + "tiitiiit", + "tiitiit", + "tiitiiti", + "tiitiitt", + "tiitirrt", + "tiitirtr", + "tiitirtt", + "tiitit", + "tiititii", + "tiititir", + "tiititit", + "tiititt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrt", + "tiitrtrr", + "tiitrtt", + "tiitrtti", + "tiitrttr", + "tiitrttt", + "tiitt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiit", + "tiittiti", + "tiittitt", + "tiittrrt", + "tiittrt", + "tiittrtr", + "tiittrtt", + "tiittt", + "tiittt i", + "tiittti", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtii", + "tirrrtrr", + "tirrrtti", + "tirrrttt", + "tirrt", + "tirrti", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtt", + "tirrttii", + "tirrttrr", + "tirrttrt", + "tirrttt", + "tirrtttt", + "tirt", + "tirt rtt", + "tirt trr", + "tirti", + "tirtii", + "tirtiiii", + "tirtiirt", + "tirtirrr", + "tirtirt", + "tirtirti", + "tirtirtt", + "tirtitii", + "tirtitit", + "tirtitrr", + "tirtitrt", + "tirtrrrr", + "tirtrrrt", + "tirtrrti", + "tirtrrtr", + "tirtrrtt", + "tirtrt", + "tirtrtrr", + "tirtrtrt", + "tirtrttt", + "tirtt", + "tirtti t", + "tirttii", + "tirttrrr", + "tirttrrt", + "tirttrtr", + "tirttrtt", + "tirttt", + "tirtttit", + "tirtttrr", + "tirtttt", + "tirtttti", + "tirttttr", + "tirttttt", + "tit", + "tit ttt", + "tit tttt", + "titi", + "titii", + "titiiii", + "titiiiii", + "titiiiir", + "titiiiit", + "titiiirt", + "titiiit", + "titiiiti", + "titiiitr", + "titiiitt", + "titiirrr", + "titiirtt", + "titiit", + "titiitii", + "titiitit", + "titiitrr", + "titiitt", + "titiitti", + "titiittr", + "titiittt", + "titirrrr", + "titirrrt", + "titirrti", + "titirtti", + "titit", + "tititi", + "tititii", + "tititiii", + "tititiit", + "tititirt", + "titititi", + "titititt", + "tititrrt", + "tititrtr", + "tititrtt", + "tititti", + "titittii", + "titittit", + "titittrr", + "titittt", + "titittti", + "tititttr", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrti", + "titrrtrr", + "titrrtrt", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrtrrr", + "titrtrrt", + "titrtrti", + "titrtrtt", + "titrtt", + "titrttrr", + "titrttrt", + "titrtttt", + "titt", + "titt ttt", + "titti", + "tittii", + "tittiiii", + "tittiiir", + "tittiiit", + "tittiit", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirrr", + "tittirtt", + "tittit", + "tittitii", + "tittitit", + "tittitrr", + "tittitt", + "tittitti", + "tittittr", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrtt", + "tittrtrt", + "tittrttr", + "tittt", + "tittti", + "titttii", + "titttiii", + "titttit", + "titttiti", + "titttitr", + "titttitt", + "titttrr", + "titttrrr", + "titttrtt", + "titttt", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt i", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt rr", + "trrrt rt", + "trrrt tr", + "trrrti", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtit", + "trrrtiti", + "trrrtitr", + "trrrtitt", + "trrrtr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttr", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt i", + "trrt r", + "trrt tt", + "trrt iir", + "trrt rrr", + "trrt trr", + "trrt ttr", + "trrt ttt", + "trrti", + "trrtii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirr", + "trrtiiti", + "trrtiitt", + "trrtirrr", + "trrtirt", + "trrtirtr", + "trrtit", + "trrtitir", + "trrtitit", + "trrtittt", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtti", + "trrttiii", + "trrttiit", + "trrttirr", + "trrttirt", + "trrttiti", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt r", + "trt t", + "trt t", + "trt tr", + "trt rrr", + "trt rrt", + "trt t", + "trt iitt", + "trt rrrr", + "trt rrrt", + "trt rrt", + "trt rrtr", + "trt rrtt", + "trt rtrr", + "trt rtt", + "trt rttt", + "trt t", + "trt trrr", + "trt trt", + "trt trtr", + "trt trtt", + "trt tt", + "trt ttti", + "trt tttt", + "trti", + "trtii", + "trtiii", + "trtiiiii", + "trtiiiir", + "trtiirrt", + "trtiirti", + "trtirrrr", + "trtirrtt", + "trtirt", + "trtirtir", + "trtirtr", + "trtirtt", + "trtirttt", + "trtit", + "trtitiit", + "trtitirt", + "trtitit", + "trtititt", + "trtitrrt", + "trtitrt", + "trtitrtr", + "trtitrtt", + "trtittrt", + "trtittti", + "trtitttr", + "trtr", + "trtrrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt i", + "trtrrt t", + "trtrrti", + "trtrrtii", + "trtrrtir", + "trtrrtit", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt t", + "trtrt t", + "trtrtiii", + "trtrtiir", + "trtrtiti", + "trtrtitr", + "trtrtitt", + "trtrtr", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtti", + "trtrttii", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt r", + "trtt t", + "trtt rr", + "trtt tt", + "trtt rrr", + "trtt tti", + "trtt ttr", + "trtti", + "trttii", + "trttiiii", + "trttiiit", + "trttiiti", + "trttirtr", + "trttirtt", + "trttit", + "trttitit", + "trttitrr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt t", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt rr", + "trttt tt", + "trttti", + "trtttiii", + "trtttiir", + "trtttirr", + "trtttirt", + "trtttit", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttrr", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttti", + "trttttii", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt t", + "tt rr", + "tt tt", + "tt iii", + "tt rrr", + "tt t", + "tt trt", + "tt iiii", + "tt r", + "tt rrrr", + "tt t", + "tt trrr", + "tt trt", + "tt trtr", + "tt ttrr", + "tt ttt", + "tt tttr", + "tt tttt", + "tt ii", + "tt iiiii", + "tt itiii", + "tt rrrrr", + "tt rrrrt", + "tt rrrtt", + "tt rrtrr", + "tt rrttt", + "tt rt rt", + "tt rtrtr", + "tt rttrr", + "tt rtttr", + "tt rtttt", + "tt t", + "tt ti", + "tt tiiti", + "tt titrr", + "tt trrrr", + "tt trrtt", + "tt trtrt", + "tt trttt", + "tt tt", + "tt ttiii", + "tt ttiit", + "tt ttrrr", + "tt ttrrt", + "tt ttrtt", + "tt ttt", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt ttttr", + "tt ttttt", + "tti", + "tti tt", + "tti iii", + "tti tti", + "tti t", + "ttii", + "ttii i", + "ttiii", + "ttiii it", + "ttiii tt", + "ttiiii", + "ttiiii i", + "ttiiii t", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtr", + "ttiiirtt", + "ttiiit", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitt", + "ttiiitti", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrt", + "ttiirrtr", + "ttiirtii", + "ttiirtrr", + "ttiirtt", + "ttiirttr", + "ttiirttt", + "ttiit", + "ttiit t", + "ttiit tt", + "ttiiti", + "ttiiti r", + "ttiitiii", + "ttiitiir", + "ttiitiit", + "ttiitit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtt", + "ttiitt", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirittt", + "ttirrrrr", + "ttirrrrt", + "ttirrrti", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrttr", + "ttirrttt", + "ttirt", + "ttirt tr", + "ttirtiii", + "ttirtrrr", + "ttirtrrt", + "ttirtrtr", + "ttirttrr", + "ttirttrt", + "ttirttt", + "ttirtttt", + "ttit", + "ttit ttt", + "ttiti", + "ttiti t", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiirr", + "ttitiirt", + "ttitiiti", + "ttitiitt", + "ttitit", + "ttititii", + "ttititit", + "ttititr", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtii", + "ttitrtit", + "ttitrtrr", + "ttitrtti", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitti", + "ttittii", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitr", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittt i", + "ttittti", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttr", + "ttrr", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt tt", + "ttrrtiii", + "ttrrtiir", + "ttrrtiit", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtiti", + "ttrrtrr", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt t", + "ttrrtti", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt irt", + "ttrt trt", + "ttrt ttt", + "ttrtiiii", + "ttrtiit", + "ttrtiitr", + "ttrtiitt", + "ttrtirrr", + "ttrtirti", + "ttrtirtt", + "ttrtit", + "ttrtitii", + "ttrtitt", + "ttrtitti", + "ttrtittt", + "ttrtrrr", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrt t", + "ttrtrti", + "ttrtrtii", + "ttrtrtir", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt r", + "ttrtt rt", + "ttrtt tr", + "ttrtt tt", + "ttrtti", + "ttrttiii", + "ttrttiir", + "ttrttirr", + "ttrttiti", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt t", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt r", + "ttt r", + "ttt tt", + "ttt iii", + "ttt rrr", + "ttt rtt", + "ttt t", + "ttt tr", + "ttt tt", + "ttt ttt", + "ttt iiii", + "ttt rrrr", + "ttt rrtr", + "ttt rrtt", + "ttt rttt", + "ttt t tr", + "ttt tiii", + "ttt trrr", + "ttt trrt", + "ttt trtt", + "ttt tt", + "ttt tti", + "ttt ttit", + "ttt ttrt", + "ttt ttt", + "ttt ttti", + "ttt tttt", + "ttti", + "ttti rtt", + "tttii", + "tttii tt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirt", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitir", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttir", + "tttirrrr", + "tttirrrt", + "tttirrtt", + "tttirt", + "tttirtrr", + "tttirtrt", + "tttirtt", + "tttirtti", + "tttirttr", + "tttirttt", + "tttit", + "tttit t", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitt t", + "tttitti", + "tttittii", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrrr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt t", + "tttrrtii", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrti", + "tttrtiii", + "tttrtirr", + "tttrtirt", + "tttrtiti", + "tttrtitr", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt i", + "tttrtti", + "tttrttir", + "tttrttit", + "tttrttr", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt t", + "tttt rr", + "tttt tr", + "tttt tt", + "tttt iii", + "tttt iit", + "tttt rrr", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t t", + "tttt tt", + "tttt tti", + "tttt ttt", + "tttti", + "tttti tt", + "ttttii", + "ttttii t", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirt", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrirt", + "ttttrr", + "ttttrrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrtii", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt t", + "ttttt ii", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tt", + "ttttti", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrr", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr23": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i r", + "i t", + "i i", + "i ii", + "i ir", + "i it", + "i rr", + "i t", + "i i", + "i iii", + "i iit", + "i irr", + "i irt", + "i it", + "i itr", + "i itt", + "i rrr", + "i ttt", + "i i", + "i i tt", + "i ii i", + "i iiii", + "i iirr", + "i iitt", + "i irrr", + "i irrt", + "i irt", + "i irtt", + "i it", + "i it r", + "i itrt", + "i itt", + "i ittt", + "i rrrr", + "i ttrt", + "i tttt", + "i i", + "i i iii", + "i iii", + "i iiii", + "i iiiii", + "i iiiit", + "i iiirr", + "i iirrr", + "i iirrt", + "i iitrr", + "i irrrr", + "i irrti", + "i irrtr", + "i irrtt", + "i irt r", + "i irt t", + "i irtrr", + "i irttr", + "i irttt", + "i it", + "i it r", + "i itiii", + "i itiir", + "i ititr", + "i itrrr", + "i itrrt", + "i itrtr", + "i itrtt", + "i ittt", + "i itttt", + "i rrrrr", + "i rrt", + "i rtrtr", + "i t", + "i tttrt", + "i ttttr", + "i ttttt", + "i i", + "i i ii", + "i i t", + "i ii", + "i ii iii", + "i ii rrr", + "i iii", + "i iii ii", + "i iiii", + "i iiiiii", + "i iiiiir", + "i iiiiit", + "i iiiirt", + "i iiirrr", + "i iiirti", + "i iiittt", + "i iirrrr", + "i iirrrt", + "i iirtrr", + "i iit", + "i iitiii", + "i iitrrr", + "i iitt", + "i iittti", + "i irrrrr", + "i irrrrt", + "i irrrtr", + "i irrtir", + "i irrtrr", + "i irrtrt", + "i irrttt", + "i irtitt", + "i irtrrr", + "i irtttt", + "i it", + "i itirrr", + "i itrrrr", + "i itrtrr", + "i itrttt", + "i itt rt", + "i ittii", + "i ittitt", + "i ittrrt", + "i ittrt", + "i ittrti", + "i ittrtr", + "i itttrr", + "i itttt", + "i itttti", + "i ittttt", + "i rrrrrr", + "i rrrrrt", + "i rrrrtr", + "i rrrtrr", + "i rrrtrt", + "i rrttt", + "i rtrrrr", + "i rtttir", + "i rttttt", + "i t trt", + "i t tiii", + "i tiitii", + "i tirrtt", + "i trrrrr", + "i trrrti", + "i trrrtt", + "i trrtt", + "i trtrrr", + "i trtrrt", + "i trttii", + "i tti", + "i ttitti", + "i ttt rt", + "i ttt tt", + "i tttrrt", + "i tttrtr", + "i tttt t", + "i ttttit", + "i ttttt", + "i tttttr", + "i tttttt", + "ii", + "ii i", + "ii i iii", + "ii ii ii", + "ii iiiii", + "ii iiirt", + "ii iiiti", + "ii iitrr", + "ii irrtr", + "ii itrt", + "ii t", + "ii trrrr", + "ii ttitr", + "ii ttrrr", + "ii tttii", + "ii tttt", + "iii", + "iii rtt", + "iii trr", + "iii ttr", + "iii i", + "iii i ii", + "iii iiii", + "iii iirt", + "iii irrr", + "iii it t", + "iii itrr", + "iii rrrr", + "iiii", + "iiii ii", + "iiii t", + "iiii i", + "iiii ii", + "iiii iii", + "iiii iti", + "iiii itr", + "iiii rrr", + "iiii tii", + "iiii tt", + "iiii tti", + "iiiii", + "iiiii ii", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt r", + "iiiirtir", + "iiiirtit", + "iiiirtrr", + "iiiirtti", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiit ii", + "iiiit rr", + "iiiit t", + "iiiiti", + "iiiiti i", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitirt", + "iiiitit", + "iiiititi", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtit", + "iiirrtrr", + "iiirrtrt", + "iiirrtti", + "iiirrttr", + "iiirrttt", + "iiirtiii", + "iiirtiir", + "iiirtirr", + "iiirtrrr", + "iiirtrrt", + "iiirtrt", + "iiirtt", + "iiirttt", + "iiirttti", + "iiirtttt", + "iiit", + "iiit iit", + "iiit rrr", + "iiit tir", + "iiit trt", + "iiiti", + "iiitii", + "iiitiii", + "iiitiiii", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitit", + "iiititi", + "iiititii", + "iiititit", + "iiititrt", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrti", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrtir", + "iiitrtrr", + "iiitrtti", + "iiitrttt", + "iiitt", + "iiitt ii", + "iiittii", + "iiittiii", + "iiittiit", + "iiittit", + "iiittiti", + "iiittrrr", + "iiittrrt", + "iiittrtt", + "iiittt", + "iiittt i", + "iiittti", + "iiitttii", + "iiitttit", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrt r", + "iirrrtii", + "iirrrtir", + "iirrrtit", + "iirrrtrr", + "iirrrtrt", + "iirrrtt", + "iirrrtti", + "iirrrttr", + "iirrrttt", + "iirrt", + "iirrtiii", + "iirrtitt", + "iirrtrrr", + "iirrtrtt", + "iirrtt", + "iirrtti", + "iirrttii", + "iirrttrt", + "iirrttti", + "iirrtttr", + "iirrtttt", + "iirt", + "iirt rrr", + "iirt rrt", + "iirt rti", + "iirt ttr", + "iirtiiii", + "iirtiiti", + "iirtittt", + "iirtrrrr", + "iirtrrrt", + "iirtrrtt", + "iirtrt", + "iirtrtrt", + "iirtrtt", + "iirtrtti", + "iirtt", + "iirtt t", + "iirtt ti", + "iirttiii", + "iirttiir", + "iirttrrr", + "iirttrtt", + "iirttt", + "iirttttt", + "iit", + "iit i", + "iit i", + "iit iii", + "iit rrtr", + "iit rtrr", + "iit tttr", + "iiti", + "iiti iti", + "iitii", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiit", + "iitiiitr", + "iitiirrr", + "iitiirt", + "iitiirtr", + "iitiitii", + "iitiitir", + "iitiitit", + "iitiitrr", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitirtti", + "iitit", + "iititi", + "iititi i", + "iititii", + "iititiii", + "iititiit", + "iititirr", + "iitititi", + "iititrrr", + "iititrrt", + "iititrt", + "iititrti", + "iititt", + "iitittii", + "iitittit", + "iitittrr", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrt", + "iitrrrti", + "iitrrrtr", + "iitrrrtt", + "iitrrtii", + "iitrrtir", + "iitrrtrr", + "iitrrtrt", + "iitrrttt", + "iitrt", + "iitrtitr", + "iitrtrrr", + "iitrtrt", + "iitrtrtt", + "iitrtt", + "iitrttit", + "iitrttrr", + "iitrttrt", + "iitrtttr", + "iitrtttt", + "iitt", + "iitt tt", + "iitt ttt", + "iitti", + "iittii", + "iittii i", + "iittiiii", + "iittiiit", + "iittiit", + "iittiiti", + "iittiitt", + "iittirrt", + "iittirtt", + "iittit", + "iittitii", + "iittitit", + "iittitrr", + "iittitt", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrtr", + "iittrt", + "iittrtrr", + "iittrtrt", + "iittrttr", + "iittrttt", + "iittt", + "iittt tt", + "iittti", + "iitttiii", + "iitttiit", + "iitttirr", + "iitttit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrti", + "iitttrtt", + "iitttt", + "iitttt t", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrtii", + "irrrrtrr", + "irrrrtrt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrti", + "irrrtiii", + "irrrtiir", + "irrrtiti", + "irrrtrrr", + "irrrtrrt", + "irrrtrt", + "irrrtrti", + "irrrtrtr", + "irrrtrtt", + "irrrtt", + "irrrtt t", + "irrrttii", + "irrrttit", + "irrrttrt", + "irrrttt", + "irrrttti", + "irrrtttr", + "irrrtttt", + "irrt", + "irrt rrt", + "irrt trr", + "irrt ttr", + "irrtii", + "irrtiiii", + "irrtiiir", + "irrtiiti", + "irrtiitr", + "irrtirrr", + "irrtittt", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrti", + "irrtrrtr", + "irrtrrtt", + "irrtrtir", + "irrtrtrr", + "irrtrtrt", + "irrtrttt", + "irrtt", + "irrtti", + "irrttirt", + "irrttrrr", + "irrttrtr", + "irrttrtt", + "irrttti", + "irrtttii", + "irrtttrr", + "irrtttrt", + "irrtttt", + "irrtttti", + "irrttttt", + "irt", + "irt rrtr", + "irt tttr", + "irti", + "irtii", + "irtiiiii", + "irtirrrr", + "irtirrti", + "irtitiii", + "irtitrrr", + "irtittt", + "irtrrrrr", + "irtrrrrt", + "irtrrrt", + "irtrrrtr", + "irtrrrtt", + "irtrrtir", + "irtrrtrr", + "irtrrtrt", + "irtrrtti", + "irtrrttr", + "irtrrttt", + "irtrt", + "irtrtrrt", + "irtrttit", + "irtrttrr", + "irtrttrt", + "irtrttti", + "irtrtttt", + "irtt", + "irtt ttt", + "irttiiii", + "irttirtr", + "irttitii", + "irttrrrr", + "irttrrrt", + "irttrrtt", + "irttrt", + "irttrtrr", + "irttrttr", + "irttrttt", + "irttti", + "irtttiit", + "irtttrrr", + "irtttrrt", + "irtttrtt", + "irtttt", + "irtttti", + "irttttii", + "irttttir", + "irttttrr", + "irtttttr", + "irtttttt", + "it", + "it ii", + "it trt", + "it tt", + "it ttt", + "it iiit", + "it iirrt", + "it rrrrr", + "it rrrrt", + "it rrrti", + "it t i", + "it ttrrt", + "iti", + "itii", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiit", + "itiiiirr", + "itiiiirt", + "itiiiiti", + "itiiiitt", + "itiiirrt", + "itiiirtt", + "itiiit", + "itiiiti", + "itiiitii", + "itiiitir", + "itiiitit", + "itiiitti", + "itiiittt", + "itiirrtt", + "itiirtir", + "itiirtrr", + "itiit", + "itiit it", + "itiiti", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiittii", + "itiittti", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrtr", + "itirrrtt", + "itirrt", + "itirrtrt", + "itirrttt", + "itirt", + "itit", + "itit it", + "ititi", + "ititiii", + "ititiiii", + "ititiiti", + "ititiitt", + "ititit", + "itititii", + "itititit", + "itititrr", + "itititti", + "ititittt", + "ititrrrr", + "ititrrtt", + "ititrtrr", + "ititt", + "itittii", + "itittiii", + "itittiit", + "itittirr", + "itittiti", + "itittitt", + "itittrrt", + "itittrtr", + "itittrtt", + "itittt", + "ititttii", + "ititttit", + "ititttrr", + "ititttrt", + "ititttti", + "itittttr", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrtrr", + "itrrrttr", + "itrrrttt", + "itrrt", + "itrrti", + "itrrtirr", + "itrrtitt", + "itrrtrrr", + "itrrtrrt", + "itrrtrt", + "itrrtrtr", + "itrrtrtt", + "itrrtt", + "itrrttii", + "itrrttrr", + "itrrtttr", + "itrrtttt", + "itrt", + "itrt t", + "itrtiiit", + "itrtiirr", + "itrtiitt", + "itrtitit", + "itrtrrrr", + "itrtrrrt", + "itrtrrti", + "itrtrrtr", + "itrtrtii", + "itrtrtrr", + "itrtrtti", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrtt t", + "itrttrtr", + "itrttrtt", + "itrttt", + "itrtttrr", + "itrtttrt", + "itrtttt", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt tr", + "itt trt", + "itt i", + "itt t tt", + "itti", + "ittii tr", + "ittiiii", + "ittiiiii", + "ittiiiit", + "ittiiirr", + "ittiiit", + "ittiiiti", + "ittiiitt", + "ittiirrr", + "ittiirrt", + "ittiirtt", + "ittiit", + "ittiit i", + "ittiitii", + "ittiitit", + "ittiitt", + "ittiitti", + "ittiittr", + "ittiittt", + "ittirrrr", + "ittirrtr", + "ittit", + "ittitiii", + "ittitiit", + "ittititi", + "ittititt", + "ittitrrr", + "ittitrtr", + "ittitt", + "ittittit", + "ittittrr", + "ittittt", + "ittitttr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtt", + "ittrrt", + "ittrrtrr", + "ittrrtrt", + "ittrrttr", + "ittrrttt", + "ittrt t", + "ittrt tr", + "ittrtirr", + "ittrtrtr", + "ittrtrtt", + "ittrtt", + "ittrttrr", + "ittrttrt", + "ittrttt", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt t", + "ittt trt", + "ittt ttt", + "ittti", + "ittti ii", + "itttiii", + "itttiiii", + "itttiiit", + "itttiiti", + "itttiitt", + "itttit", + "itttitii", + "itttitit", + "itttitrr", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrtii", + "itttrtrr", + "itttrtrt", + "itttrtt", + "itttrttt", + "itttt", + "ittttii", + "ittttiii", + "ittttiit", + "ittttirr", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttt t", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "ritrrrtt", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt i", + "rrrrt ii", + "rrrrt ir", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt ti", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt t", + "rrrt ii", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt ti", + "rrrt tr", + "rrrt tt", + "rrrt iii", + "rrrt iit", + "rrrt irr", + "rrrt irt", + "rrrt iti", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt ti", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti it", + "rrrtii", + "rrrtii r", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtit r", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt r", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt ii", + "rrt tr", + "rrt i", + "rrt iii", + "rrt rrr", + "rrt trr", + "rrt trt", + "rrt ttt", + "rrt i", + "rrt ii", + "rrt irrr", + "rrt irrt", + "rrt irti", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rtii", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt tirr", + "rrt trrr", + "rrt trrt", + "rrt trtt", + "rrt ttit", + "rrt ttrr", + "rrt ttti", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti rr", + "rrtii", + "rrtii ii", + "rrtiii", + "rrtiii i", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirti", + "rrtiirtr", + "rrtiit", + "rrtiit r", + "rrtiiti", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirtii", + "rrtirtrr", + "rrtirtrt", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitii", + "rrtitiii", + "rrtitiir", + "rrtititi", + "rrtitrrr", + "rrtitrrt", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtitti", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt i", + "rrtrrt r", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt t", + "rrtrt ii", + "rrtrt rr", + "rrtrt rt", + "rrtrt t", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrtii", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt r", + "rrtrtt t", + "rrtrtti", + "rrtrttii", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt t", + "rrtt ii", + "rrtt rr", + "rrtt iir", + "rrtt itr", + "rrtt rrr", + "rrtt rrt", + "rrtt rtr", + "rrtt rtt", + "rrtt t", + "rrtt ti", + "rrtt tii", + "rrtt trr", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiiti", + "rrttirrr", + "rrttirrt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttitii", + "rrttitrr", + "rrttitrt", + "rrttitti", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt ii", + "rrttt rr", + "rrttt rt", + "rrttt t", + "rrttt tr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttit", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt r", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt it", + "rt rr", + "rt tr", + "rt tt", + "rt irt", + "rt trr", + "rt ttr", + "rt irrr", + "rt rrrr", + "rt rrtr", + "rt t", + "rt t rr", + "rt iirrr", + "rt iit", + "rt irrrr", + "rt irrt", + "rt irt", + "rt it", + "rt itiit", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrtti", + "rt rrttr", + "rt rrttt", + "rt rt", + "rt rtii", + "rt rtiii", + "rt rtrrr", + "rt rtrrt", + "rt rtrt", + "rt rtrtr", + "rt rttrr", + "rt rttti", + "rt t", + "rt t t", + "rt t ii", + "rt t rr", + "rt t rt", + "rt t ti", + "rt t tr", + "rt t tt", + "rt ti", + "rt tiiii", + "rt trrrr", + "rt trrrt", + "rt trrtr", + "rt trrtt", + "rt trtrt", + "rt trttt", + "rt tt", + "rt ttitr", + "rt ttrrr", + "rt ttrrt", + "rt ttrti", + "rt ttrtr", + "rt tttrr", + "rt tttrt", + "rt tttt", + "rt ttttr", + "rt ttttt", + "rti", + "rtii", + "rtii t", + "rtii irr", + "rtii rrr", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiiti", + "rtiiiitr", + "rtiiirrr", + "rtiiit", + "rtiiitii", + "rtiiitir", + "rtiiitrr", + "rtiiitti", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirtit", + "rtiirtrr", + "rtiirtrt", + "rtiirtt", + "rtiirtti", + "rtiirttr", + "rtiirttt", + "rtiit", + "rtiitiii", + "rtiitiit", + "rtiititt", + "rtiitrrr", + "rtiitrtr", + "rtiitrtt", + "rtiitt", + "rtiittrr", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrt r", + "rtirrtii", + "rtirrtit", + "rtirrtrr", + "rtirrtrt", + "rtirrtti", + "rtirrttt", + "rtirt", + "rtirtiii", + "rtirtiit", + "rtirtitr", + "rtirtrt", + "rtirtrtr", + "rtirtt", + "rtirttrr", + "rtirttrt", + "rtirtttt", + "rtit", + "rtit rtr", + "rtiti", + "rtitii", + "rtitiii", + "rtitiiii", + "rtitiiit", + "rtitiirr", + "rtitiitr", + "rtitirrr", + "rtitirrt", + "rtitirt", + "rtitit", + "rtititit", + "rtitittt", + "rtitrrrr", + "rtitrrrt", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtrt", + "rtitt", + "rtitt ii", + "rtittii", + "rtittitt", + "rtittrrr", + "rtittrtr", + "rtittti", + "rtitttii", + "rtitttit", + "rtitttrt", + "rtitttt", + "rtitttti", + "rtittttr", + "rtittttt", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt t", + "rtrrt rr", + "rtrrt rt", + "rtrrt t", + "rtrrt tr", + "rtrrt tt", + "rtrrti", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtitr", + "rtrrtitt", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt t", + "rtrt rr", + "rtrt t", + "rtrt tr", + "rtrt rrr", + "rtrt rrt", + "rtrt rtr", + "rtrt rtt", + "rtrt t", + "rtrt trr", + "rtrt trt", + "rtrt tt", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiir", + "rtrtiiit", + "rtrtiirr", + "rtrtiit", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirtt", + "rtrtit", + "rtrtitii", + "rtrtitir", + "rtrtitit", + "rtrtitrr", + "rtrtitrt", + "rtrtitt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt i", + "rtrtt rr", + "rtrtt rt", + "rtrtt t", + "rtrtt tr", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttirt", + "rtrttit", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt t", + "rtrttti", + "rtrtttii", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt ii", + "rtt ir", + "rtt rr", + "rtt rt", + "rtt t", + "rtt rrrr", + "rtt rrrt", + "rtt rrt", + "rtt rrtt", + "rtt rtrr", + "rtt rtrt", + "rtt rtt", + "rtt rttr", + "rtt rttt", + "rtt t", + "rtt trrr", + "rtt trrt", + "rtt trtt", + "rtt tt t", + "rtt tti", + "rtt ttrr", + "rtt ttt", + "rtt tttr", + "rtt tttt", + "rtti", + "rtti it", + "rtti itt", + "rttii", + "rttii tr", + "rttiii", + "rttiii r", + "rttiiii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirt", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirti", + "rttiirtt", + "rttiit t", + "rttiitir", + "rttiitit", + "rttiitrr", + "rttiitrt", + "rttiitt", + "rttiittr", + "rttirrrr", + "rttirrrt", + "rttirrti", + "rttirrtt", + "rttirtt", + "rttirtti", + "rttirttr", + "rttirttt", + "rttit", + "rttiti", + "rttitiii", + "rttitiir", + "rttitiit", + "rttititr", + "rttitrrr", + "rttitrti", + "rttitrtr", + "rttitrtt", + "rttittii", + "rttittit", + "rttittrr", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrti", + "rttrrtir", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt ii", + "rttrt rr", + "rttrt rt", + "rttrt t", + "rttrt ti", + "rttrt tr", + "rttrt tt", + "rttrtiii", + "rttrtirr", + "rttrtiti", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt r", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt rr", + "rttt t", + "rttt tt", + "rttt iti", + "rttt rrr", + "rttt rrt", + "rttt rtr", + "rttt trr", + "rttt trt", + "rttt tti", + "rttt ttr", + "rttt ttt", + "rttti", + "rttti tr", + "rtttiii", + "rtttiiii", + "rtttiiir", + "rtttiiit", + "rtttiirr", + "rtttiitt", + "rtttirrr", + "rtttirtt", + "rtttit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt r", + "rtttrti", + "rtttrtii", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt t", + "rtttt ii", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt ti", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t i", + "t r", + "t t", + "t i", + "t ii", + "t it", + "t rr", + "t rt", + "t t", + "t tr", + "t tt", + "t iir", + "t irr", + "t rrr", + "t rtr", + "t trr", + "t trt", + "t irrr", + "t itii", + "t rrrr", + "t rrrt", + "t rtrr", + "t trrr", + "t trtr", + "t ttt", + "t ttti", + "t tttt", + "t i ii", + "t iiiii", + "t iiirt", + "t iirtr", + "t iitii", + "t iitit", + "t iittt", + "t irrrr", + "t irrti", + "t irtrr", + "t irtrt", + "t it", + "t rrrrr", + "t rrrrt", + "t rrrt", + "t rrrtr", + "t rrrtt", + "t rrt", + "t rrtii", + "t rrtrr", + "t rrtrt", + "t rrtt", + "t rrtti", + "t rrttr", + "t rrttt", + "t rt", + "t rti", + "t rtiii", + "t rtrrt", + "t rtrt", + "t rtt", + "t rttrr", + "t t", + "t t rt", + "t t t r", + "t tirrr", + "t tit", + "t trrrr", + "t trrtr", + "t trrtt", + "t tt", + "t ttit", + "t ttitt", + "t ttrrr", + "t ttrrt", + "t ttt t", + "t tttir", + "t tttti", + "t ttttt", + "t ii", + "t iii", + "t iiiiii", + "t irrrrr", + "t irrrrt", + "t irrrtr", + "t irrrtt", + "t irrtrt", + "t irtirt", + "t it", + "t itiiii", + "t itt i", + "t ittt", + "t itttii", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrtir", + "t rrrtit", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrtti", + "t rrrttr", + "t rrt", + "t rrtirr", + "t rrtitt", + "t rrtrrr", + "t rrtrrt", + "t rrtrti", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrttii", + "t rrttrt", + "t rrttt", + "t rrttti", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt rr", + "t rt rrr", + "t rt rrt", + "t rt trr", + "t rtiiii", + "t rtiiir", + "t rtirrr", + "t rtirtr", + "t rtitii", + "t rtitrr", + "t rtitti", + "t rtrrrr", + "t rtrrrt", + "t rtrrtr", + "t rtrrtt", + "t rtrt", + "t rtrtir", + "t rtrtrr", + "t rtrtrt", + "t rtrtt", + "t rtt", + "t rttiir", + "t rttirr", + "t rttitt", + "t rttrrr", + "t rttrrt", + "t rttrtr", + "t rttrtt", + "t rttt", + "t rtttii", + "t rtttir", + "t rtttrr", + "t rtttrt", + "t rtttti", + "t rttttr", + "t rttttt", + "t t", + "t ti", + "t tiiiii", + "t tiiirr", + "t tiiirt", + "t tirrrt", + "t tititr", + "t tittit", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrtit", + "t trrtrr", + "t trrtrt", + "t trrtt", + "t trrtti", + "t trrttr", + "t trrttt", + "t trt", + "t trt t", + "t trtrrr", + "t trtrrt", + "t trtrtr", + "t trtrtt", + "t trtt", + "t trtt t", + "t trtti", + "t trttrr", + "t trttrt", + "t trttt", + "t trtttr", + "t trtttt", + "t tt", + "t tt t", + "t tt trt", + "t tt tt", + "t ttiiir", + "t ttiiit", + "t ttiitr", + "t ttitrt", + "t ttitti", + "t ttittt", + "t ttrrrr", + "t ttrrrt", + "t ttrrti", + "t ttrrtr", + "t ttrrtt", + "t ttrt", + "t ttrtrr", + "t ttrtrt", + "t ttrttr", + "t ttrttt", + "t ttt", + "t ttt r", + "t ttt t", + "t ttt tt", + "t ttti", + "t tttirt", + "t tttrrr", + "t tttrrt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttti", + "t ttttit", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t tttttr", + "t tttttt", + "ti", + "ti itti", + "ti iii", + "ti irrrr", + "ti rrtrt", + "ti rrtt", + "ti t", + "ti t rrt", + "ti trtrr", + "ti tt", + "ti ttrtt", + "ti ttt", + "ti tttti", + "ti ttttt", + "tii", + "tii itii", + "tii rrrr", + "tii tttt", + "tiii", + "tiii rt", + "tiii iii", + "tiii iti", + "tiiii", + "tiiii ii", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirtr", + "tiiiirtt", + "tiiiit", + "tiiiit t", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitti", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtr", + "tiiirrtt", + "tiiirt", + "tiiirt r", + "tiiirtit", + "tiiirtrr", + "tiiirtrt", + "tiiirtt", + "tiiirtti", + "tiiirttr", + "tiiirttt", + "tiiit", + "tiiit t", + "tiiiti", + "tiiitiii", + "tiiitiir", + "tiiitiit", + "tiiititt", + "tiiitrt", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiitt t", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrtii", + "tiirrtrt", + "tiirt", + "tiirtiii", + "tiirtrrr", + "tiirtt", + "tiirttii", + "tiirttt", + "tiirttti", + "tiirtttt", + "tiit", + "tiit tt", + "tiitii", + "tiitii t", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirr", + "tiitiit", + "tiitiitr", + "tiitiitt", + "tiitirrt", + "tiitit", + "tiititii", + "tiititit", + "tiititrr", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrtii", + "tiitrtrr", + "tiitrtrt", + "tiitrtt", + "tiitrtti", + "tiitrttr", + "tiitrttt", + "tiitt", + "tiitt t", + "tiitt tt", + "tiittii", + "tiittiii", + "tiittiit", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrtr", + "tiittrtt", + "tiittt", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtii", + "tirrrtir", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrttt", + "tirrt", + "tirrt rr", + "tirrtii", + "tirrtiii", + "tirrtrrr", + "tirrtrrt", + "tirrtrt", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrtt t", + "tirrttii", + "tirrttrt", + "tirrtttr", + "tirrtttt", + "tirt", + "tirt t", + "tirtiii", + "tirtiiii", + "tirtiitt", + "tirtirrr", + "tirtittr", + "tirtrrrr", + "tirtrrrt", + "tirtrrti", + "tirtrrtr", + "tirtrrtt", + "tirtrtii", + "tirtrtrt", + "tirtrtti", + "tirtt", + "tirtt rt", + "tirttiii", + "tirttiit", + "tirttirt", + "tirttiti", + "tirttitt", + "tirttrrr", + "tirttrrt", + "tirttt", + "tirtttir", + "tirtttit", + "tirtttt", + "tirtttti", + "tirttttt", + "tit", + "tit ii", + "tit iirr", + "tit it", + "tit t", + "titi", + "titii", + "titiii", + "titiii i", + "titiiiii", + "titiiiit", + "titiiitt", + "titiirrr", + "titiirtt", + "titiit", + "titiitii", + "titiitir", + "titiitrt", + "titiitt", + "titiitti", + "titiittr", + "titiittt", + "titirrrr", + "titirrti", + "titirt", + "titirtir", + "titirtrr", + "titirtrt", + "titirttt", + "titit", + "tititi", + "tititiii", + "tititiit", + "tititit", + "titititi", + "titititt", + "tititrrr", + "tititrrt", + "tititrti", + "tititt", + "titittii", + "titittit", + "titittti", + "tititttt", + "titrrrrr", + "titrrrt", + "titrrrtr", + "titrrrtt", + "titrrtrr", + "titrrtrt", + "titrrttr", + "titrrttt", + "titrt", + "titrt tr", + "titrtirt", + "titrtrtr", + "titrtrtt", + "titrttti", + "titrtttt", + "titt", + "titt t", + "titti", + "tittiii", + "tittiiii", + "tittiiit", + "tittiiti", + "tittiitt", + "tittitii", + "tittitit", + "tittitrr", + "tittitrt", + "tittitt", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrtr", + "tittrrtt", + "tittrtir", + "tittrtit", + "tittrtrr", + "tittrtrt", + "tittrttt", + "tittt", + "tittt tt", + "tittti", + "titttii", + "titttiii", + "titttiir", + "titttiit", + "titttirr", + "titttirt", + "titttit", + "titttitt", + "titttrrr", + "titttrrt", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt r", + "trrrt t", + "trrrt rr", + "trrrt rt", + "trrrt t", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtiti", + "trrrtitr", + "trrrtitt", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt t", + "trrt rr", + "trrt t", + "trrt tr", + "trrt tt", + "trrt iit", + "trrt rrr", + "trrt rrt", + "trrt rti", + "trrt rtr", + "trrt t t", + "trrt tit", + "trrt trr", + "trrt trt", + "trrt tt", + "trrt tti", + "trrt ttr", + "trrt ttt", + "trrti", + "trrtii", + "trrtiii", + "trrtiiii", + "trrtiirr", + "trrtiirt", + "trrtiiti", + "trrtiitr", + "trrtiitt", + "trrtirrr", + "trrtirt", + "trrtirtt", + "trrtitit", + "trrtitrt", + "trrtitt", + "trrtittr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrtii", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt rt", + "trrtt tr", + "trrtt tt", + "trrtti", + "trrttiii", + "trrttiir", + "trrttirr", + "trrttirt", + "trrttit", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrttt t", + "trrttti", + "trrtttii", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt ii", + "trt trt", + "trt rrrr", + "trt rrrt", + "trt rrtr", + "trt rtrr", + "trt rtrt", + "trt rttt", + "trt t", + "trt t rt", + "trt trrr", + "trt trtr", + "trt ttit", + "trt ttrr", + "trt tttt", + "trti", + "trti i", + "trtii", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiiiit", + "trtiiiti", + "trtiiitt", + "trtiirrr", + "trtiirt", + "trtiirti", + "trtiirtr", + "trtiirtt", + "trtiitir", + "trtiitit", + "trtiitrt", + "trtiitti", + "trtiittt", + "trtirrrr", + "trtirrrt", + "trtirrtt", + "trtirt", + "trtirtii", + "trtirtrt", + "trtit", + "trtitiii", + "trtitiit", + "trtitirr", + "trtitrrr", + "trtitrrt", + "trtitrtr", + "trtitrtt", + "trtittii", + "trtittrr", + "trtittrt", + "trtittt", + "trtittti", + "trtitttt", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt t", + "trtrrtii", + "trtrrtit", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt ii", + "trtrt rr", + "trtrt rt", + "trtrt t", + "trtrti", + "trtrtiii", + "trtrtiit", + "trtrtitt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrtt t", + "trtrtti", + "trtrttii", + "trtrttir", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rr", + "trtt t", + "trtt rrr", + "trtt rti", + "trtt rtr", + "trtt rtt", + "trtt trr", + "trtt trt", + "trtt tti", + "trtt ttt", + "trtti", + "trttii", + "trttiiii", + "trttiiir", + "trttiiit", + "trttiirr", + "trttiirt", + "trttiiti", + "trttiitt", + "trttirrr", + "trttirtt", + "trttitii", + "trttitit", + "trttitrr", + "trttitrt", + "trttitti", + "trttittr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrt r", + "trttrti", + "trttrtir", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt rr", + "trttt rt", + "trttt ti", + "trttt tr", + "trttti", + "trtttii", + "trtttiii", + "trtttiir", + "trtttiit", + "trtttirr", + "trtttirt", + "trtttit", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt t", + "trtttti", + "trttttii", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt t", + "tt ii", + "tt ir", + "tt tr", + "tt iii", + "tt iit", + "tt rrr", + "tt rtt", + "tt tt", + "tt rrrr", + "tt rrtr", + "tt t", + "tt t t", + "tt ti", + "tt trtr", + "tt tt", + "tt ttt", + "tt tttt", + "tt i", + "tt i r", + "tt iiiii", + "tt iiiir", + "tt iiirr", + "tt iiiti", + "tt iiitr", + "tt irrtt", + "tt ititt", + "tt itrt", + "tt rrrrr", + "tt rrrrt", + "tt rrrti", + "tt rrrtr", + "tt rrrtt", + "tt rrt", + "tt rrtii", + "tt rrtrr", + "tt rrtrt", + "tt rrttt", + "tt rtrrr", + "tt rtrtr", + "tt rtrtt", + "tt rtt", + "tt rttii", + "tt rttrt", + "tt rtttt", + "tt t", + "tt t tr", + "tt t rrr", + "tt t rrt", + "tt t rtt", + "tt t ttt", + "tt ti ti", + "tt titrr", + "tt titrt", + "tt trrrr", + "tt trrrt", + "tt trrt", + "tt trrtr", + "tt trt t", + "tt trtrr", + "tt trtrt", + "tt trttr", + "tt trttt", + "tt tt", + "tt tt t", + "tt tt t", + "tt tt tr", + "tt tt tt", + "tt ttrrr", + "tt ttrrt", + "tt ttrtr", + "tt ttrtt", + "tt ttt", + "tt tttii", + "tt tttit", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti ii", + "tti iir", + "tti iiii", + "tti trrt", + "tti trtr", + "ttii", + "ttii trr", + "ttiii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirt", + "ttiiit", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrti", + "ttiirrtr", + "ttiirrtt", + "ttiirtii", + "ttiirtrt", + "ttiit", + "ttiitiii", + "ttiitiit", + "ttiitirr", + "ttiitit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittir", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrtt", + "ttirrtrt", + "ttirrtti", + "ttirrttt", + "ttirtrrr", + "ttirtrrt", + "ttirtrtr", + "ttirtt", + "ttirttir", + "ttirttrr", + "ttirttrt", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit rtt", + "ttit t", + "ttiti", + "ttitii", + "ttitii t", + "ttitiiii", + "ttitiiit", + "ttitiirr", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitit t", + "ttititii", + "ttititit", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtii", + "ttitrtit", + "ttitrtrr", + "ttitrtrt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt it", + "ttitti", + "ttittiii", + "ttittiit", + "ttittirr", + "ttittirt", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrt", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt ir", + "ttrrt rr", + "ttrrt rt", + "ttrrt tt", + "ttrrti", + "ttrrtiii", + "ttrrtit", + "ttrrtiti", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtt r", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt tt", + "ttrt iir", + "ttrt iit", + "ttrt irr", + "ttrt rrr", + "ttrt rrt", + "ttrt rt", + "ttrt rtr", + "ttrt trt", + "ttrt tt", + "ttrt ttr", + "ttrt ttt", + "ttrti", + "ttrtiiii", + "ttrtiirr", + "ttrtiit", + "ttrtiitt", + "ttrtirrr", + "ttrtirrt", + "ttrtirti", + "ttrtit", + "ttrtitrr", + "ttrtitt", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrtit", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt rr", + "ttrtt rt", + "ttrtt tt", + "ttrtti", + "ttrttiit", + "ttrttirt", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrttt t", + "ttrtttii", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt ii", + "ttt ir", + "ttt rr", + "ttt rt", + "ttt tr", + "ttt tt", + "ttt rrr", + "ttt rrt", + "ttt rtr", + "ttt t", + "ttt trr", + "ttt i", + "ttt iiii", + "ttt itii", + "ttt ittt", + "ttt rrrr", + "ttt rrrt", + "ttt rrtr", + "ttt rt", + "ttt rt t", + "ttt rtrr", + "ttt rtrt", + "ttt rttt", + "ttt t", + "ttt t rr", + "ttt t tt", + "ttt tii", + "ttt trrr", + "ttt trrt", + "ttt trti", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt tt r", + "ttt tt t", + "ttt ttii", + "ttt ttit", + "ttt ttrt", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti t", + "ttti tt", + "ttti rrr", + "ttti rrt", + "ttti t", + "ttti tti", + "ttti ttt", + "tttii", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirti", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrtr", + "tttirtrr", + "tttirtrt", + "tttirtt", + "tttirttr", + "tttirttt", + "tttit", + "tttit rt", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrt", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrt t", + "tttrrtii", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt t", + "tttrt it", + "tttrt rr", + "tttrt rt", + "tttrt t", + "tttrt ti", + "tttrt tr", + "tttrt tt", + "tttrtiii", + "tttrtiir", + "tttrtirr", + "tttrtitt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt r", + "tttrtti", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt ii", + "tttt it", + "tttt rr", + "tttt t", + "tttt tr", + "tttt tt", + "tttt iii", + "tttt itt", + "tttt rrr", + "tttt rrt", + "tttt rti", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt ti", + "tttt tii", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti ti", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttit t", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrti", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt i", + "ttttt r", + "ttttt t", + "ttttt ii", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr24": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i i", + "i t", + "i ittti", + "i rrrrr", + "i rttti", + "i t tr", + "i tt", + "i tttii", + "i ttttt", + "i ii", + "i iii", + "i iiii i", + "i iiiiii", + "i iiiitt", + "i iiittt", + "i irrrrr", + "i it", + "i itiiii", + "i rr", + "i rrrtrr", + "i rt", + "i rtt tr", + "i t", + "i tiit", + "i trrttr", + "i ttiiii", + "ii", + "ii i", + "ii r", + "ii t", + "ii ii", + "ii tt", + "ii iiit", + "ii i ii", + "ii iiii", + "ii iiiii", + "ii iit", + "ii itii", + "ii rrrrr", + "ii t rtt", + "ii trttt", + "ii ttiii", + "ii tttt", + "ii ttttt", + "iii", + "iii ii", + "iii iii", + "iii iiii", + "iii iiir", + "iii iiit", + "iii iirr", + "iii rrrr", + "iii trrr", + "iii ttit", + "iiii", + "iiii ii", + "iiii iii", + "iiii tii", + "iiii trt", + "iiiii", + "iiiii i", + "iiiii ii", + "iiiii it", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiii t", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiir", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiir", + "iiiiirr", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitr", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrr", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirtii", + "iiiirtir", + "iiiirtit", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiit ii", + "iiiit ti", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiitirr", + "iiiititi", + "iiiititt", + "iiiitrr", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrr", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrt", + "iiirrtii", + "iiirrtrr", + "iiirrtt", + "iiirrttt", + "iiirt", + "iiirtii", + "iiirtiii", + "iiirtiit", + "iiirtirr", + "iiirtiti", + "iiirttii", + "iiirttrr", + "iiirttt", + "iiirtttt", + "iiit", + "iiit rt", + "iiiti", + "iiiti i", + "iiitii", + "iiitiii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitirrr", + "iiitit", + "iiititii", + "iiititit", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrti", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrtii", + "iiitrtir", + "iiitrtrr", + "iiitrtrt", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitti", + "iiittii", + "iiittiii", + "iiittiit", + "iiittit", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrti", + "iiittrtr", + "iiittt", + "iiittti", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtii", + "iirrrtir", + "iirrrtrr", + "iirrrtrt", + "iirrrtt", + "iirrrtti", + "iirrt", + "iirrtiii", + "iirrtiit", + "iirrtrrr", + "iirrttit", + "iirrttrr", + "iirrttrt", + "iirrttt", + "iirrtttr", + "iirrtttt", + "iirt", + "iirtiiir", + "iirtiiit", + "iirtiirr", + "iirtiitt", + "iirtirrt", + "iirtrrrr", + "iirtrrti", + "iirtrrtr", + "iirtrrtt", + "iirtrtrt", + "iirtrtti", + "iirtt rt", + "iirttiii", + "iirttrrr", + "iirttrrt", + "iirtttii", + "iirtttt", + "iirttttt", + "iit", + "iit rrrt", + "iiti", + "iitii", + "iitiii t", + "iitiiii", + "iitiiiii", + "iitiiiir", + "iitiiiit", + "iitiiirr", + "iitiiiti", + "iitiiitr", + "iitiiitt", + "iitiirrr", + "iitiirrt", + "iitiit", + "iitiitii", + "iitiitit", + "iitiitti", + "iitiittt", + "iitit", + "iititi", + "iititiii", + "iititiit", + "iititit", + "iititrrr", + "iititrrt", + "iitittit", + "iitittrr", + "iitittti", + "iititttt", + "iitr", + "iitrrrrr", + "iitrrrrt", + "iitrrrtr", + "iitrrt", + "iitrrtii", + "iitrrtr", + "iitrrtrr", + "iitrrtrt", + "iitrrttt", + "iitrt", + "iitrt rr", + "iitrtiii", + "iitrtit", + "iitrtiti", + "iitrtitt", + "iitrtrrr", + "iitrtrrt", + "iitrtrtr", + "iitrtrtt", + "iitrtt", + "iitrttti", + "iitrtttt", + "iitt", + "iitti", + "iittiiii", + "iittiiit", + "iittiirr", + "iittiirt", + "iittiiti", + "iittiitt", + "iittirrr", + "iittirrt", + "iittit", + "iittitii", + "iittitit", + "iittitrr", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrtt", + "iittrtrr", + "iittrttr", + "iittrttt", + "iittt", + "iittti i", + "iitttiii", + "iitttiir", + "iitttiit", + "iitttirt", + "iitttit", + "iitttiti", + "iitttitr", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irr", + "irrrr", + "irrrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrti", + "irrrrtii", + "irrrrtir", + "irrrrtrr", + "irrrrtt", + "irrrrttt", + "irrrt", + "irrrtii", + "irrrtiii", + "irrrtitr", + "irrrtrrr", + "irrrtrrt", + "irrrtrtr", + "irrrtt", + "irrrttir", + "irrrttit", + "irrrttrt", + "irrrttt", + "irrrtttr", + "irrrtttt", + "irrt", + "irrtiiii", + "irrtiirr", + "irrtirrt", + "irrtit", + "irrtitii", + "irrtitti", + "irrtrrrr", + "irrtrrti", + "irrtrrtt", + "irrtt", + "irrttiii", + "irrttirr", + "irrttiti", + "irrttrrr", + "irrttrrt", + "irrttt", + "irrtttir", + "irrtttit", + "irrtttrt", + "irrtttt", + "irrtttti", + "irrttttr", + "irrttttt", + "irt", + "irti", + "irtiiii", + "irtiiiii", + "irtiiiit", + "irtiit", + "irtiitti", + "irtirrrt", + "irtitiii", + "irtititi", + "irtitt", + "irtittt", + "irtrrrr", + "irtrrrrr", + "irtrrrrt", + "irtrrrt", + "irtrrtrt", + "irtrrttt", + "irtrt", + "irtrtiii", + "irtrtiir", + "irtrtrrt", + "irtrtt", + "irtrttrt", + "irtrttt", + "irtrtttt", + "irtt", + "irttiiii", + "irttiiit", + "irttrrrr", + "irttrrtr", + "irttrrtt", + "irttrt", + "irttrtrt", + "irttrttt", + "irttt", + "irtttrti", + "irtttrtt", + "irtttt", + "irttttii", + "irttttti", + "irtttttt", + "it", + "it i", + "it iii", + "it ttii", + "it trrrr", + "it ttt", + "iti", + "iti ti", + "itii", + "itii iii", + "itii rrr", + "itiii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiit", + "itiiiirr", + "itiiiiti", + "itiiiitt", + "itiiirrr", + "itiiit", + "itiiitii", + "itiiitir", + "itiiitit", + "itiiitrr", + "itiiitrt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirt", + "itiirti", + "itiirtii", + "itiit", + "itiit tt", + "itiitiii", + "itiitiit", + "itiitit", + "itiititt", + "itiitrti", + "itiitt", + "itiittii", + "itiittit", + "itiittt", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrti", + "itirrrtr", + "itirrtir", + "itirrtrt", + "itirrttt", + "itit", + "ititi", + "ititii", + "ititiiii", + "ititiiit", + "ititiitt", + "ititirrt", + "itititii", + "itititit", + "ititittt", + "ititrttt", + "ititt", + "itittiii", + "itittiit", + "itittiti", + "itittitt", + "itittrrr", + "ititttii", + "ititttit", + "ititttti", + "itittttr", + "itittttt", + "itr", + "itrrrrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrtii", + "itrrrtrr", + "itrrrtrt", + "itrrrtt", + "itrrrttt", + "itrrt", + "itrrtiir", + "itrrtrrr", + "itrrtrtr", + "itrrtt", + "itrrttir", + "itrrttrr", + "itrrttrt", + "itrrtttr", + "itrrtttt", + "itrt", + "itrt iit", + "itrt itt", + "itrtiiii", + "itrtiirr", + "itrtiirt", + "itrtitit", + "itrtitti", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrrti", + "itrtrrtr", + "itrtrrtt", + "itrtrtr", + "itrtrtrr", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrtti", + "itrttitr", + "itrttrrt", + "itrtttrr", + "itrtttt", + "itrtttti", + "itrttttt", + "itt", + "itt t", + "itti", + "itti tt", + "ittii", + "ittiii", + "ittiiiii", + "ittiiiit", + "ittiiirr", + "ittiiiti", + "ittiiitt", + "ittiirrr", + "ittiitit", + "ittiitt", + "ittiittt", + "ittirrrr", + "ittirt", + "ittirtit", + "ittirtrr", + "ittit", + "ittiti", + "ittitiii", + "ittitiit", + "ittititt", + "ittitrrr", + "ittitrrt", + "ittitrtr", + "ittitrtt", + "ittitt", + "ittitt t", + "ittitti", + "ittittii", + "ittittit", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrtii", + "ittrrtrr", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrtiit", + "ittrtitt", + "ittrtrrr", + "ittrtrrt", + "ittrtt", + "ittrttrr", + "ittrttrt", + "ittrttti", + "ittrtttr", + "ittrtttt", + "ittt", + "ittti", + "itttii", + "itttiiii", + "itttiiit", + "itttiiti", + "itttiitt", + "itttirrt", + "itttit", + "itttitii", + "itttitit", + "itttitrr", + "itttitrt", + "itttitt", + "itttitti", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtt", + "itttrtrr", + "itttrtrt", + "itttrttt", + "itttt", + "itttt it", + "itttt tt", + "itttti", + "ittttii", + "ittttiii", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitr", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrti t", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtir", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt rr", + "rrrt tr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rtt", + "rrrt t", + "rrrt t t", + "rrrt trr", + "rrrt trt", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt rt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttr", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt rt", + "rrt rrr", + "rrt rtr", + "rrt trr", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rtii", + "rrt rtir", + "rrt rtrr", + "rrt rttt", + "rrt t", + "rrt t rt", + "rrt trrr", + "rrt trt", + "rrt tt", + "rrt ttt", + "rrt tttr", + "rrti", + "rrti rrt", + "rrtii", + "rrtii t", + "rrtii ii", + "rrtii rr", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirtt", + "rrtiit", + "rrtiitii", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitt", + "rrtiitti", + "rrtiittr", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirtii", + "rrtirtrr", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtiti", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtitirt", + "rrtitit", + "rrtititt", + "rrtitrrr", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtitti", + "rrtittii", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtitttr", + "rrtitttt", + "rrtrr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrti", + "rrtrrtii", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt t", + "rrtrt tt", + "rrtrti", + "rrtrti t", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtiti", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtti", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt tr", + "rrtt rrr", + "rrtt rrt", + "rrtt rtr", + "rrtt rtt", + "rrtt t t", + "rrtt tt", + "rrtti", + "rrttii", + "rrttiii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirti", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit t", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt t", + "rrttrtii", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt r", + "rrttt rr", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttr", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt i", + "rt r", + "rt t", + "rt rr", + "rt rrr", + "rt rrrr", + "rt rrrt", + "rt rrtr", + "rt rrtt", + "rt rt t", + "rt rtrr", + "rt rtt", + "rt t t", + "rt ti", + "rt trrr", + "rt trrt", + "rt trtt", + "rt i", + "rt rrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrti", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtrr", + "rt rrtt", + "rt rrttr", + "rt rt", + "rt rtrrr", + "rt rtrrt", + "rt rtrtt", + "rt rtt", + "rt rtttt", + "rt t", + "rt tirrr", + "rt tirtr", + "rt trrrr", + "rt trrrt", + "rt trrtr", + "rt trrtt", + "rt trtrt", + "rt trttt", + "rt tt", + "rt ttrrr", + "rt ttrt", + "rt ttrtt", + "rt ttti", + "rt tttrt", + "rt tttt", + "rt ttttt", + "rti", + "rtii", + "rtiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiiti", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirti", + "rtiiirtr", + "rtiiit", + "rtiiitii", + "rtiiitit", + "rtiiitrr", + "rtiiitt", + "rtiiitti", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrtt", + "rtiirt", + "rtiirtii", + "rtiirtrr", + "rtiirtrt", + "rtiirtti", + "rtiirttr", + "rtiirttt", + "rtiit", + "rtiiti", + "rtiitiii", + "rtiitiir", + "rtiitiit", + "rtiitirr", + "rtiitirt", + "rtiititi", + "rtiitrrr", + "rtiitrti", + "rtiitt", + "rtiittrt", + "rtiittti", + "rtiitttr", + "rtiitttt", + "rtirrrr", + "rtirrrrr", + "rtirrrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrti", + "rtirrtrr", + "rtirrtt", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirtiii", + "rtirtrr", + "rtirtrrr", + "rtirtrrt", + "rtirtrtt", + "rtirtt", + "rtirttii", + "rtirttrr", + "rtirttti", + "rtirtttr", + "rtirtttt", + "rtit", + "rtitiiii", + "rtitiiit", + "rtitirrr", + "rtitirti", + "rtitirtt", + "rtitit", + "rtititt", + "rtititti", + "rtitrrrr", + "rtitrrrt", + "rtitrrtt", + "rtitrt", + "rtitrtit", + "rtitrtrr", + "rtitrtrt", + "rtitrtti", + "rtitrttt", + "rtitt", + "rtittiii", + "rtittiir", + "rtittirt", + "rtittitt", + "rtittrrr", + "rtittrti", + "rtittrtt", + "rtittt", + "rtitttit", + "rtitttrr", + "rtitttrt", + "rtitttt", + "rtittttr", + "rtittttt", + "rtr", + "rtrr", + "rtrrrr", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrti", + "rtrrrtii", + "rtrrrtit", + "rtrrrtr", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt t", + "rtrrt ii", + "rtrrt tr", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtirr", + "rtrrtirt", + "rtrrtitr", + "rtrrtitt", + "rtrrtrr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt rr", + "rtrt t", + "rtrt tt", + "rtrt rtr", + "rtrt trr", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiir", + "rtrtiirt", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirt", + "rtrtirtr", + "rtrtirtt", + "rtrtit", + "rtrtitii", + "rtrtitit", + "rtrtitrr", + "rtrtitt", + "rtrtitti", + "rtrtittt", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrti", + "rtrtrtii", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt tr", + "rtrtti", + "rtrttii", + "rtrttiii", + "rtrttiir", + "rtrttirr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttr", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt tr", + "rtt r", + "rtt rrt", + "rtt trr", + "rtt iiii", + "rtt rrrr", + "rtt rrrt", + "rtt rrtr", + "rtt rtrr", + "rtt ttrt", + "rtt ttti", + "rtt tttt", + "rtti", + "rtti ttt", + "rttii", + "rttiii", + "rttiiii", + "rttiiiii", + "rttiiiit", + "rttiiirr", + "rttiiit", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirt", + "rttiirtt", + "rttiit", + "rttiitii", + "rttiitir", + "rttiitti", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtit", + "rttirtrr", + "rttirttr", + "rttirttt", + "rttit", + "rttitiii", + "rttititr", + "rttitrrr", + "rttitrrt", + "rttitrt", + "rttitrtr", + "rttitt", + "rttittii", + "rttittir", + "rttittrr", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttr", + "rttrrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrti", + "rttrrtir", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt rr", + "rttrtiir", + "rttrtirr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt rt", + "rttt trr", + "rttt tt", + "rttt ttt", + "rttti", + "rtttiii", + "rtttiiii", + "rtttiiit", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirt", + "rtttirtt", + "rtttit", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrtii", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt t", + "rtttt rr", + "rtttt t", + "rtttt tr", + "rtttt tt", + "rtttti", + "rtttti t", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttr", + "rttttrr", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttr", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t i", + "t ii", + "t r", + "t rr", + "t rt", + "t t", + "t tr", + "t tt", + "t rtr", + "t t", + "t ttt", + "t rr", + "t rrrr", + "t t", + "t t t", + "t ttrt", + "t tttt", + "t ii i", + "t iii", + "t itrrr", + "t ittii", + "t r", + "t rrr", + "t rrrr", + "t rrrrr", + "t rrrt", + "t rrt", + "t rrtr", + "t rt", + "t rt t", + "t rti", + "t rtii", + "t rtrt", + "t rtt", + "t rttr", + "t rtttt", + "t t rt", + "t t t", + "t t tr", + "t t rrt", + "t t rtt", + "t trr", + "t trrr", + "t trrrr", + "t trrrt", + "t trrtt", + "t trtrr", + "t trtrt", + "t trtt", + "t tt", + "t tt t", + "t tt tt", + "t ttrrt", + "t ttrtr", + "t tttti", + "t ttttt", + "t i", + "t ii", + "t iiirt", + "t ittii", + "t ittttt", + "t rr", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrtrt", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrti", + "t rrtrrr", + "t rrtrrt", + "t rrtrt", + "t rrtrtr", + "t rrtrtt", + "t rrtt", + "t rrtt t", + "t rrttrr", + "t rrttrt", + "t rrttt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt rr", + "t rt t", + "t rt rt", + "t rtiti", + "t rtrrrr", + "t rtrtrt", + "t rtrttr", + "t rtt", + "t rttrrr", + "t rttrtr", + "t rttrtt", + "t rtttt", + "t t", + "t t tr", + "t t trr", + "t t tt", + "t t ttt", + "t t rt", + "t t tt", + "t t ttt", + "t ti", + "t tittrt", + "t titttt", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrrtt", + "t trrt", + "t trrtrr", + "t trrtrt", + "t trtrr", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrtr", + "t trtrtt", + "t trttit", + "t trttrr", + "t trttrt", + "t trttt", + "t tt", + "t tt tt", + "t tti", + "t ttirrr", + "t ttrrrr", + "t ttrrrt", + "t ttrrtt", + "t ttrtrr", + "t ttrttr", + "t ttrttt", + "t ttt", + "t tttiii", + "t tttrrt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t ttttrt", + "t ttttt", + "t ttttti", + "t tttttr", + "t tttttt", + "ti", + "ti i", + "ti t", + "ti tr", + "ti tttr", + "ti tttt", + "ti i ii", + "ti iiiii", + "ti iiiir", + "ti rrttt", + "ti t t", + "ti titit", + "tii", + "tiii", + "tiii it", + "tiiii", + "tiiii ii", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirti", + "tiiiirtr", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrr", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtr", + "tiiirrtt", + "tiiirt", + "tiiirtii", + "tiiirtir", + "tiiirtrr", + "tiiirttr", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitiii", + "tiiitiir", + "tiiitiit", + "tiiitirt", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrt", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrtii", + "tiirrtir", + "tiirrtrr", + "tiirrtrt", + "tiirrtti", + "tiirrttt", + "tiirt", + "tiirtiii", + "tiirtiit", + "tiirtrrt", + "tiirtrtr", + "tiirtrtt", + "tiirttii", + "tiirttrr", + "tiirttti", + "tiit", + "tiit tt", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirt", + "tiitiiti", + "tiitiitt", + "tiitirrr", + "tiitirtt", + "tiitit", + "tiititii", + "tiititrr", + "tiititt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrt", + "tiitrrtr", + "tiitrtrr", + "tiitrtt", + "tiitrttt", + "tiitt", + "tiitti", + "tiittii", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittiti", + "tiittitr", + "tiittitt", + "tiittrrr", + "tiittt", + "tiittti", + "tiitttii", + "tiitttir", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrr", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtir", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrttr", + "tirrt", + "tirrti", + "tirrtiii", + "tirrtiir", + "tirrtiti", + "tirrtitt", + "tirrtrrr", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrttii", + "tirrttir", + "tirrttrr", + "tirrttt", + "tirrtttt", + "tirt", + "tirt rrt", + "tirtii", + "tirtiiii", + "tirtiitt", + "tirtirti", + "tirtitrr", + "tirtitti", + "tirtittt", + "tirtrrrr", + "tirtrrrt", + "tirtrrtr", + "tirtrrtt", + "tirtrtrr", + "tirtrtrt", + "tirtt", + "tirttrrr", + "tirttrt", + "tirttt", + "tirtttii", + "tirtttti", + "tirttttt", + "tit", + "tit t", + "tit tttt", + "titi", + "titii", + "titii tt", + "titiiiii", + "titiiiit", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirrt", + "titiirti", + "titiirtt", + "titiit", + "titiitii", + "titiitir", + "titiitit", + "titiitrr", + "titiitti", + "titiittt", + "titirrrr", + "titirrti", + "titirrtr", + "titirtit", + "titirttr", + "titirttt", + "titit", + "tititi", + "tititiii", + "tititiit", + "titititi", + "titititr", + "titititt", + "tititrrt", + "tititrtr", + "tititrtt", + "tititt", + "titittii", + "titittir", + "titittit", + "titittrr", + "titittrt", + "titittt", + "titittti", + "tititttr", + "tititttt", + "titrrrr", + "titrrrrr", + "titrrrrt", + "titrrrt", + "titrrrtr", + "titrrrtt", + "titrrtrr", + "titrrtt", + "titrrtti", + "titrrttr", + "titrrttt", + "titrt", + "titrtiii", + "titrtiit", + "titrtitt", + "titrtrrr", + "titrtrrt", + "titrtrtt", + "titrtti", + "titrttir", + "titrttrr", + "titrttrt", + "titrttti", + "titrtttt", + "titt", + "titt rrr", + "titti", + "tittii", + "tittiiii", + "tittiiir", + "tittiirr", + "tittiiti", + "tittiitt", + "tittirrt", + "tittirti", + "tittirtr", + "tittit", + "tittitii", + "tittitit", + "tittitrr", + "tittitt", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrtr", + "tittrt", + "tittrtii", + "tittrtrr", + "tittrtrt", + "tittrttr", + "tittrttt", + "tittt", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttirt", + "titttiti", + "titttitt", + "titttrrr", + "titttrtt", + "titttt", + "titttt i", + "titttti", + "tittttii", + "tittttir", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt rr", + "trrrt t", + "trrrt tr", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtirr", + "trrrtirt", + "trrrtitt", + "trrrtr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt t", + "trrrtti", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt tr", + "trrt rrr", + "trrt rti", + "trrti", + "trrtiiii", + "trrtiiit", + "trrtiirr", + "trrtiirt", + "trrtiiti", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirtr", + "trrtirtt", + "trrtit", + "trrtitii", + "trrtitir", + "trrtitrr", + "trrtitt", + "trrtitti", + "trrtittr", + "trrtittt", + "trrtrr", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrti", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt t", + "trrtti", + "trrttii", + "trrttiii", + "trrttiir", + "trrttiit", + "trrttirr", + "trrttirt", + "trrttit", + "trrttiti", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttti", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttr", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt r", + "trt t", + "trt iii", + "trt trr", + "trt trt", + "trt rrrr", + "trt rrtr", + "trt rtrr", + "trt rttt", + "trt t", + "trt trrr", + "trt trtr", + "trt tt", + "trti", + "trtii", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiiiir", + "trtiiirr", + "trtiiitt", + "trtiirrr", + "trtiirrt", + "trtiirti", + "trtiirtt", + "trtiitii", + "trtiitti", + "trtiittt", + "trtirrrr", + "trtirrrt", + "trtirrtr", + "trtirtit", + "trtirtrt", + "trtirttt", + "trtit", + "trtiti", + "trtitiii", + "trtitiir", + "trtitiit", + "trtitit", + "trtititt", + "trtitrrr", + "trtitrti", + "trtitt", + "trtittii", + "trtittrr", + "trtittrt", + "trtittti", + "trtitttt", + "trtrrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrti", + "trtrrtii", + "trtrrtir", + "trtrrtit", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt rr", + "trtrt rt", + "trtrtirr", + "trtrtirt", + "trtrtit", + "trtrtitt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt t", + "trtrtti", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt trt", + "trtt tt", + "trtt ttt", + "trtti", + "trttiiii", + "trttiiir", + "trttiiit", + "trttiirt", + "trttiit", + "trttiiti", + "trttiitt", + "trttirrr", + "trttirtr", + "trttirtt", + "trttit", + "trttitii", + "trttitit", + "trttitrr", + "trttitrt", + "trttitt", + "trttittr", + "trttittt", + "trttrrr", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrtii", + "trttrtir", + "trttrtit", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt t", + "trttt rr", + "trttt tr", + "trttt tt", + "trtttiii", + "trtttirt", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttr", + "trtttrr", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrti", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt r", + "tt t", + "tt rr", + "tt rt", + "tt tr", + "tt tt", + "tt rrr", + "tt ttt", + "tt iiii", + "tt iiit", + "tt rrrr", + "tt rrrt", + "tt trr", + "tt trtr", + "tt i", + "tt iiitr", + "tt iittr", + "tt irtrr", + "tt itrrr", + "tt ittt", + "tt rrrrr", + "tt rrrrt", + "tt rrrtr", + "tt rrrtt", + "tt rrt", + "tt rrtt", + "tt rrttt", + "tt rt", + "tt rtrtt", + "tt rtttt", + "tt t", + "tt t rr", + "tt t tr", + "tt t tt", + "tt t tii", + "tt trrr", + "tt trrrt", + "tt trrt", + "tt trrtr", + "tt trt r", + "tt trtrt", + "tt trtti", + "tt trttt", + "tt tt", + "tt ttiti", + "tt ttrrr", + "tt ttrtr", + "tt ttrtt", + "tt tttrr", + "tt tttt", + "tt tttti", + "tt ttttr", + "tt ttttt", + "tti", + "tti it", + "ttii", + "ttii t", + "ttiii", + "ttiii tt", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtt", + "ttiiit", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirt", + "ttiirti", + "ttiirtit", + "ttiirtrr", + "ttiirtrt", + "ttiirttt", + "ttiit", + "ttiit rr", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiir", + "ttiitiit", + "ttiitirr", + "ttiitirt", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrtit", + "ttirrtrr", + "ttirrtt", + "ttirrttr", + "ttirt", + "ttirtirt", + "ttirtrrr", + "ttirtrrt", + "ttirtrt", + "ttirtrtt", + "ttirtt", + "ttirttrr", + "ttirtttt", + "ttit", + "ttit ti", + "ttiti", + "ttitii", + "ttitiiii", + "ttitiiit", + "ttitiiti", + "ttitiitt", + "ttitirrr", + "ttitirrt", + "ttitit", + "ttititit", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrti", + "ttitrtrr", + "ttitrtrt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitt t", + "ttitt tt", + "ttitti", + "ttittiii", + "ttittiir", + "ttittiit", + "ttittirr", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrirrrr", + "ttrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrtii", + "ttrrrtir", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt t", + "ttrrt tt", + "ttrrtiii", + "ttrrtirr", + "ttrrtirt", + "ttrrtit", + "ttrrtiti", + "ttrrtitr", + "ttrrtitt", + "ttrrtr", + "ttrrtrr", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtti", + "ttrrttii", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt t", + "ttrt rtr", + "ttrt trr", + "ttrt ttt", + "ttrtiiii", + "ttrtiiit", + "ttrtiirr", + "ttrtiirt", + "ttrtiiti", + "ttrtiitr", + "ttrtirrr", + "ttrtirtr", + "ttrtirtt", + "ttrtit", + "ttrtitti", + "ttrtittr", + "ttrtittt", + "ttrtrrr", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrtii", + "ttrtrtir", + "ttrtrtr", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt t", + "ttrttiii", + "ttrttiir", + "ttrttiit", + "ttrttirt", + "ttrttit", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttti", + "ttrtttii", + "ttrtttit", + "ttrtttr", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt t", + "ttt rt", + "ttt t", + "ttt ti", + "ttt rtr", + "ttt t", + "ttt tt", + "ttt ttt", + "ttt i", + "ttt ittt", + "ttt rrrr", + "ttt rrrt", + "ttt rrtr", + "ttt rtrr", + "ttt t", + "ttt tiii", + "ttt trrt", + "ttt trtr", + "ttt tt", + "ttt tt r", + "ttt ttrt", + "ttt ttti", + "ttt tttt", + "ttti", + "ttti rtr", + "tttii", + "tttii i", + "tttii rt", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirt", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrr", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrtr", + "tttirrtt", + "tttirt", + "tttirtrt", + "tttirttt", + "tttit", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirr", + "tttitirt", + "tttitit", + "tttititi", + "tttititt", + "tttitrr", + "tttitrrr", + "tttitrrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrtii", + "tttrrtir", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt rr", + "tttrtiii", + "tttrtirr", + "tttrtit", + "tttrtitr", + "tttrtitt", + "tttrtrr", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtti", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt ir", + "tttt rr", + "tttt rt", + "tttt t", + "tttt tr", + "tttt tt", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt trr", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti i", + "tttti t", + "tttti ii", + "tttti tt", + "ttttii", + "ttttii i", + "ttttii t", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirti", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttit i", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttritt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrti", + "ttttrtii", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt i", + "ttttt r", + "ttttt t", + "ttttt i", + "ttttt it", + "ttttt rr", + "ttttt rt", + "ttttt tr", + "ttttt tt", + "ttttti", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrr", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr25": [ + "-1", + "-2", + "-6", + "i", + "i iiii", + "i rttt", + "i tttt", + "i i", + "i iiiiii", + "i iiirrt", + "i iitii", + "i iittti", + "i irrtrr", + "i iti", + "i ittiti", + "i rtrttt", + "i trrrrr", + "i trtrtt", + "i tt tr", + "i tttttr", + "i tttttt", + "ii", + "ii i", + "ii iii", + "ii iiiii", + "ii rtt t", + "ii tiiii", + "iii", + "iii iii", + "iii ti", + "iii iiii", + "iii t tt", + "iii tt", + "iiii", + "iiii rr", + "iiii tt", + "iiii iii", + "iiiii", + "iiiii ii", + "iiiii t", + "iiiiii", + "iiiiii i", + "iiiiii r", + "iiiiii t", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtt", + "iiiiit", + "iiiiitii", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirt r", + "iiiirtii", + "iiiirtti", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiitirr", + "iiiitit", + "iiiititi", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrti", + "iiiitrtt", + "iiiitt", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtir", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrtti", + "iiirrttr", + "iiirrttt", + "iiirt", + "iiirtiii", + "iiirtiit", + "iiirtrr", + "iiirtrrr", + "iiirtrrt", + "iiirtrtt", + "iiirtt", + "iiirtt t", + "iiirtti", + "iiirttit", + "iiirttrr", + "iiirttrt", + "iiirttt", + "iiirtttt", + "iiit", + "iiit rrr", + "iiit trr", + "iiiti", + "iiitiii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitirrr", + "iiitirtt", + "iiitit", + "iiititii", + "iiititit", + "iiititti", + "iiitittt", + "iiitrr", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrtii", + "iiitrtrr", + "iiitrtrt", + "iiitrtt", + "iiitrtti", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitti", + "iiittii", + "iiittiii", + "iiittiit", + "iiittirr", + "iiittirt", + "iiittit", + "iiittiti", + "iiittitt", + "iiittrr", + "iiittrrr", + "iiittrrt", + "iiittrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttii", + "iiitttir", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirirrrr", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrti", + "iirrrtii", + "iirrrtir", + "iirrrtrr", + "iirrrtrt", + "iirrrttt", + "iirrt", + "iirrtiti", + "iirrtitt", + "iirrtrtr", + "iirrtt", + "iirrttir", + "iirrtttr", + "iirrtttt", + "iirt", + "iirtiiii", + "iirtiirr", + "iirtiiti", + "iirtirrr", + "iirtrrrr", + "iirtrrrt", + "iirtrrtr", + "iirtrtrr", + "iirtrtti", + "iirtt", + "iirttiii", + "iirttiti", + "iirttrtr", + "iirttttt", + "iit", + "iit iiii", + "iiti", + "iitii", + "iitii ti", + "iitiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiirt", + "iitiiiti", + "iitiiitr", + "iitiiitt", + "iitiirrr", + "iitiit", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitt", + "iitiitti", + "iitiittt", + "iitirrrr", + "iitirrrt", + "iitirttt", + "iitit", + "iititiii", + "iititiir", + "iititiit", + "iititirr", + "iitititr", + "iitititt", + "iitittii", + "iitittit", + "iitittrr", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrti", + "iitrrrtr", + "iitrrtit", + "iitrrtrr", + "iitrrtt", + "iitrrttt", + "iitrt", + "iitrtiii", + "iitrtrrr", + "iitrtrtt", + "iitrttii", + "iitrttrt", + "iitrtttr", + "iitrtttt", + "iitt", + "iitt tt", + "iitti", + "iitti ii", + "iittii", + "iittiii", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiirt", + "iittiit", + "iittiiti", + "iittiitr", + "iittiitt", + "iittirrr", + "iittit", + "iittiti", + "iittitii", + "iittitit", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrtr", + "iittrrtt", + "iittrt", + "iittrtrr", + "iittrttt", + "iittt", + "iittti", + "iitttiii", + "iitttiit", + "iitttiti", + "iitttitr", + "iitttitt", + "iitttrrr", + "iitttrtr", + "iitttt", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "ir", + "irrr", + "irrrrrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrtii", + "irrrrtir", + "irrrrtit", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrtti", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrtiit", + "irrrtiti", + "irrrtitt", + "irrrtrrr", + "irrrtrrt", + "irrrtrti", + "irrrtt", + "irrrttii", + "irrrttrr", + "irrrttti", + "irrrtttt", + "irrt", + "irrt rr", + "irrt trt", + "irrtiii", + "irrtiiii", + "irrtirrt", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrt", + "irrtrtrr", + "irrtrtrt", + "irrtrtti", + "irrtrttt", + "irrtt", + "irrttirr", + "irrttiti", + "irrttrrt", + "irrttrti", + "irrttrtt", + "irrttt", + "irrtttrr", + "irrtttrt", + "irrttttt", + "irt", + "irt rrrr", + "irti", + "irtiiiii", + "irtiiiir", + "irtiiiit", + "irtiiirt", + "irtiiiti", + "irtiirrr", + "irtiitii", + "irtirrrr", + "irtitt", + "irtittt", + "irtittti", + "irtrrrrr", + "irtrrrrt", + "irtrrtrr", + "irtrrttt", + "irtrtiii", + "irtrtiit", + "irtrtit", + "irtrtrrr", + "irtrtrrt", + "irtrtttr", + "irtrtttt", + "irtt", + "irtt ir", + "irttiiii", + "irttiirr", + "irttiit", + "irttittt", + "irttrtt", + "irttt", + "irtttitr", + "irtttrrr", + "irtttrtt", + "irtttt", + "irtttttt", + "it", + "it i", + "it t", + "it tittt", + "iti", + "iti iiii", + "itii", + "itii irt", + "itiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiirr", + "itiiiiti", + "itiiiitr", + "itiiiitt", + "itiiirrr", + "itiiirtt", + "itiiiti", + "itiiitii", + "itiiitit", + "itiiitrr", + "itiiitrt", + "itiiitt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirtrr", + "itiirtti", + "itiirttt", + "itiit", + "itiitii", + "itiitiii", + "itiitiit", + "itiititi", + "itiititt", + "itiitrrt", + "itiitt", + "itiittii", + "itiittit", + "itiittt", + "itiittti", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirrrti", + "itirrt", + "itirtttr", + "itirtttt", + "itit", + "itit iii", + "ititi", + "ititii", + "ititiii", + "ititiiii", + "ititiiit", + "ititiirr", + "ititiit", + "ititiiti", + "ititiitt", + "itititii", + "itititit", + "itititt", + "itititti", + "ititittt", + "ititrrrr", + "ititrrt", + "ititrrti", + "ititrttt", + "ititt", + "itittiii", + "itittiit", + "itittirr", + "itittitt", + "itittrrr", + "itittrrt", + "itittt", + "ititttii", + "ititttrt", + "ititttt", + "ititttti", + "itittttt", + "itr", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrtr", + "itrrrrtt", + "itrrrt", + "itrrrti", + "itrrrtit", + "itrrrtrt", + "itrrrttt", + "itrrtirr", + "itrrtitt", + "itrrtrrr", + "itrrtt", + "itrrttrt", + "itrrttt", + "itrrtttt", + "itrt", + "itrt iit", + "itrt rrt", + "itrtiiii", + "itrtiitr", + "itrtirtt", + "itrtitir", + "itrtrrrt", + "itrtrrtr", + "itrtrtrr", + "itrtrttt", + "itrttiii", + "itrttiti", + "itrttrrr", + "itrttrrt", + "itrttrtt", + "itrtttit", + "itrtttrr", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt t", + "itti", + "ittii", + "ittiiii", + "ittiiiii", + "ittiiirt", + "ittiiiti", + "ittiiitt", + "ittiirrr", + "ittiirrt", + "ittiirti", + "ittiitii", + "ittiitit", + "ittiittt", + "ittirrrt", + "ittirrtr", + "ittirtit", + "ittirtrt", + "ittirtt", + "ittit", + "ittitiii", + "ittitiit", + "ittitirt", + "ittititi", + "ittititt", + "ittitrr", + "ittitt", + "ittittit", + "ittittt", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrti", + "ittrrrtr", + "ittrrrtt", + "ittrrtrr", + "ittrrtrt", + "ittrrttt", + "ittrtiit", + "ittrtirt", + "ittrtitt", + "ittrtrrr", + "ittrtrrt", + "ittrttrr", + "ittrttt", + "ittrttti", + "ittrtttt", + "ittt", + "ittt trt", + "ittt ttt", + "ittti", + "itttii", + "itttiiii", + "itttiiit", + "itttiirr", + "itttiirt", + "itttiiti", + "itttiitt", + "itttirrt", + "itttirt", + "itttit", + "itttitii", + "itttitit", + "itttitr", + "itttitt", + "itttittt", + "itttrrrr", + "itttrrt", + "itttrrtr", + "itttrrtt", + "itttrtrr", + "itttrtrt", + "itttrtt", + "itttrtti", + "itttrttt", + "itttt", + "itttt ii", + "itttti", + "ittttii", + "ittttiii", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitr", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt i", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt rr", + "rrrt rt", + "rrrt iii", + "rrrt rr", + "rrrt rrr", + "rrrt rrt", + "rrrt rt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt t t", + "rrrt tii", + "rrrt trr", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtii r", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirr", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtit t", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt t", + "rrrtt t", + "rrrtt tr", + "rrrtti", + "rrrtti t", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt i", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt rrr", + "rrt rt", + "rrt rtt", + "rrt trt", + "rrt iiit", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rtrr", + "rrt rtt", + "rrt rtti", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt t rr", + "rrt trrr", + "rrt trrt", + "rrt tt", + "rrt ttrr", + "rrt ttrt", + "rrt tttt", + "rrti", + "rrtii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirt", + "rrtiirti", + "rrtiirtt", + "rrtiit", + "rrtiiti", + "rrtiitii", + "rrtiitir", + "rrtiitr", + "rrtiitrr", + "rrtiitt", + "rrtiitti", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirtii", + "rrtirtir", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirttt", + "rrtit", + "rrtitii", + "rrtitiii", + "rrtitiit", + "rrtitirt", + "rrtititi", + "rrtitrrr", + "rrtitrrt", + "rrtitrtr", + "rrtitrtt", + "rrtitt", + "rrtitt i", + "rrtittii", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtittti", + "rrtitttr", + "rrtitttt", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt rr", + "rrtrt rt", + "rrtrti", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtiti", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt rrr", + "rrtt rtr", + "rrtt t", + "rrtt trr", + "rrtt trt", + "rrtt ttt", + "rrtti", + "rrtti t", + "rrttii", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit t", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitt", + "rrttitti", + "rrttittt", + "rrttr", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt t", + "rrttrti", + "rrttrtii", + "rrttrtir", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt t", + "rrttt rt", + "rrttt ti", + "rrttt tt", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttit", + "rrttttr", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt t", + "rt rrr", + "rt trr", + "rt trt", + "rt rrrr", + "rt t", + "rt tirt", + "rt trrr", + "rt trt", + "rt irrrr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrrtt", + "rt rrt", + "rt rrtrr", + "rt rrtrt", + "rt rrttr", + "rt rt rr", + "rt rt tr", + "rt rtrrr", + "rt rtrrt", + "rt rtttr", + "rt trrrr", + "rt trrt", + "rt trrtt", + "rt trt", + "rt trtrr", + "rt trtt", + "rt tt", + "rt ttrrr", + "rt ttrtt", + "rt tttrt", + "rt tttt", + "rt ttttt", + "rti", + "rti rtii", + "rtii", + "rtii rr", + "rtiii", + "rtiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirti", + "rtiiirtt", + "rtiiitii", + "rtiiitrr", + "rtiiitrt", + "rtiiittr", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirrti", + "rtiirrtr", + "rtiirrtt", + "rtiirt", + "rtiirtii", + "rtiirtrr", + "rtiirttt", + "rtiit", + "rtiitiir", + "rtiitirr", + "rtiititi", + "rtiitrrr", + "rtiitrrt", + "rtiitt", + "rtiittii", + "rtiittit", + "rtiittrr", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrti", + "rtirrrtt", + "rtirrt", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrtti", + "rtirrttt", + "rtirt", + "rtirtiii", + "rtirtirr", + "rtirtirt", + "rtirtr", + "rtirtrrr", + "rtirtrtr", + "rtirtt", + "rtirtti", + "rtirttii", + "rtirttir", + "rtirttrr", + "rtirttrt", + "rtirtttr", + "rtirtttt", + "rtit", + "rtit rtr", + "rtitiiii", + "rtitiirr", + "rtitirrr", + "rtitirrt", + "rtitirti", + "rtitit", + "rtititir", + "rtititit", + "rtititti", + "rtitittt", + "rtitrrrr", + "rtitrrrt", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtii", + "rtitrtrr", + "rtitrttt", + "rtitt", + "rtitti", + "rtittiii", + "rtittiti", + "rtittitt", + "rtittrrr", + "rtittrt", + "rtittrtr", + "rtittt", + "rtittti", + "rtitttrt", + "rtitttt", + "rtittttt", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt rr", + "rtrrt t", + "rtrrt tr", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiir", + "rtrrtirr", + "rtrrtirt", + "rtrrtitt", + "rtrrtr", + "rtrrtrr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt rt", + "rtrt iii", + "rtrt rrr", + "rtrt rrt", + "rtrt rtr", + "rtrt t", + "rtrti", + "rtrtii", + "rtrtiii", + "rtrtiiii", + "rtrtiiit", + "rtrtiirt", + "rtrtiitt", + "rtrtirrr", + "rtrtirrt", + "rtrtirtr", + "rtrtit", + "rtrtitii", + "rtrtitit", + "rtrtitrt", + "rtrtittr", + "rtrtittt", + "rtrtrr", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt tt", + "rtrttiii", + "rtrttiir", + "rtrttiit", + "rtrttirr", + "rtrttit", + "rtrttitt", + "rtrttrr", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt r", + "rtrttt t", + "rtrttti", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt r", + "rtt rrr", + "rtt rtr", + "rtt trr", + "rtt tt", + "rtt ttt", + "rtt rrrr", + "rtt rrrt", + "rtt rrtr", + "rtt rrtt", + "rtt t", + "rtt trrt", + "rtt tttt", + "rtti", + "rtti iir", + "rtti tit", + "rttii", + "rttii tt", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirti", + "rttiit", + "rttiiti", + "rttiitii", + "rttiitrr", + "rttiitrt", + "rttiittr", + "rttirrrr", + "rttirrrt", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtit", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirttt", + "rttit", + "rttitiir", + "rttitirt", + "rttitrrr", + "rttitrt", + "rttitrti", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttitti", + "rttittir", + "rttittrr", + "rttittrt", + "rttittt", + "rttittti", + "rttitttr", + "rttitttt", + "rttr", + "rttrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt t", + "rttrrti", + "rttrrtii", + "rttrrtit", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrti", + "rttrtiii", + "rttrtitr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtt i", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt tir", + "rttt ttt", + "rttti", + "rtttiiii", + "rtttiiir", + "rtttiiit", + "rtttiirt", + "rtttiit", + "rtttiiti", + "rtttiitt", + "rtttirrr", + "rtttirrt", + "rtttirtr", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitir", + "rtttitit", + "rtttitrr", + "rtttitrt", + "rtttitt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt i", + "rtttrtii", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt t", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttr", + "rttttrr", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t rrr", + "t rrt", + "t rt", + "t t", + "t tr", + "t i", + "t iii", + "t iiit", + "t rrr", + "t rtrt", + "t t", + "t tt", + "t rrrr", + "t rrrrr", + "t rrtrt", + "t rrtt", + "t rt", + "t rtrrt", + "t rtttt", + "t t", + "t t r", + "t t t", + "t t tr", + "t t trr", + "t t tt", + "t trrrr", + "t trrrt", + "t trrt", + "t trrtt", + "t trtr", + "t trtrr", + "t tt", + "t tt t", + "t ttrrr", + "t ttrt", + "t ttt", + "t tttt", + "t ttttt", + "t i", + "t iiiiit", + "t itrrt", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrtrr", + "t rrrtt", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrtrrr", + "t rrttt", + "t rrtttt", + "t rt", + "t rt rt", + "t rt trr", + "t rtrrrr", + "t rtrtt", + "t rttiir", + "t rttirr", + "t rttt", + "t rtttt", + "t rtttti", + "t rttttt", + "t t", + "t t tt", + "t ti", + "t tiii", + "t tiirrt", + "t trrrrr", + "t trrrtt", + "t trrt", + "t trrtrr", + "t trrttt", + "t trtrr", + "t trtrrr", + "t trtrrt", + "t trtrt", + "t trtrtr", + "t tt tr", + "t ttrrrr", + "t ttt", + "t tttiii", + "t tttitt", + "t tttrrr", + "t tttrtt", + "t tttt", + "t ttttrr", + "t tttttt", + "ti", + "ti trrr", + "ti tttt", + "ti rtrrr", + "tii", + "tii iiii", + "tii itit", + "tii ittt", + "tiii", + "tiii iti", + "tiiii", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirti", + "tiiiirtr", + "tiiiirtt", + "tiiiit", + "tiiiitii", + "tiiiitir", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrtt", + "tiiirt", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitiii", + "tiiitiit", + "tiiitit", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrtt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrtii", + "tiirrtit", + "tiirrtrr", + "tiirrtrt", + "tiirrtti", + "tiirrttt", + "tiirt", + "tiirtiit", + "tiirtrrr", + "tiirtrrt", + "tiirtrtr", + "tiirtrtt", + "tiirtt", + "tiirtti", + "tiirttii", + "tiirttrr", + "tiirttt", + "tiirtttt", + "tiit", + "tiiti", + "tiitiiii", + "tiitiiir", + "tiitiirr", + "tiitiit", + "tiitiiti", + "tiitiitt", + "tiitirtt", + "tiitit", + "tiititi", + "tiititii", + "tiititit", + "tiititrr", + "tiititrt", + "tiititt", + "tiititti", + "tiitittr", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrt", + "tiitrtrt", + "tiitrtti", + "tiitt", + "tiitti", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittit", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrt", + "tiittrtt", + "tiittt", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrt r", + "tirrrtii", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrt", + "tirrt tt", + "tirrti", + "tirrtiii", + "tirrtiir", + "tirrtirt", + "tirrtrrr", + "tirrtrrt", + "tirrtrt", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrttrt", + "tirrtttr", + "tirrtttt", + "tirt", + "tirtiirr", + "tirtirtt", + "tirtit", + "tirtit t", + "tirtitrr", + "tirtrrrr", + "tirtrrrt", + "tirtrrt", + "tirtrtrr", + "tirtrtrt", + "tirtt", + "tirttiii", + "tirttit", + "tirttiti", + "tirttrtt", + "tirtttir", + "tirtttrr", + "tirtttrt", + "tirtttti", + "tirttttt", + "tit", + "titi", + "titii", + "titiiiii", + "titiiiit", + "titiiirr", + "titiiirt", + "titiiit", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirt", + "titiirtt", + "titiit", + "titiitii", + "titiitit", + "titiitrr", + "titiitt", + "titiitti", + "titiittr", + "titiittt", + "titirrrr", + "titirrti", + "titirtii", + "titirttt", + "titit", + "titit rr", + "tititi", + "tititiii", + "tititiit", + "tititirt", + "titititt", + "tititrrr", + "tititrt", + "tititrtr", + "tititrtt", + "tititt", + "titittii", + "titittit", + "titittt", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrtrr", + "titrrtrt", + "titrrtti", + "titrrttt", + "titrt", + "titrtii", + "titrtiir", + "titrtitr", + "titrtitt", + "titrtrrt", + "titrtrti", + "titrtrtt", + "titrtt", + "titrttrr", + "titrttt", + "titrtttt", + "titt", + "titt rtt", + "titti", + "titti tt", + "tittii", + "tittiiii", + "tittiiit", + "tittiirt", + "tittiit", + "tittiiti", + "tittiitt", + "tittit", + "tittitii", + "tittitrr", + "tittitrt", + "tittitt", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrt", + "tittrrti", + "tittrrtt", + "tittrtit", + "tittrttr", + "tittrttt", + "tittt", + "tittt t", + "tittti", + "titttiii", + "titttiit", + "titttirr", + "titttit", + "titttiti", + "titttitt", + "titttrrr", + "titttrt", + "titttrtr", + "titttrtt", + "titttt", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt rr", + "trrrt tt", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtirr", + "trrrtirt", + "trrrtitr", + "trrrtitt", + "trrrtr", + "trrrtrrr", + "trrrtrrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt rt", + "trrt tr", + "trrt rrr", + "trrt rrt", + "trrt rt", + "trrt t t", + "trrti", + "trrtii", + "trrtiii", + "trrtiiii", + "trrtiirt", + "trrtiiti", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirtr", + "trrtit", + "trrtitrr", + "trrtitrt", + "trrtittt", + "trrtrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtr", + "trrtrtrr", + "trrtrtrt", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt t", + "trrtt rr", + "trrtti", + "trrtti r", + "trrttiii", + "trrttiir", + "trrttirr", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt t", + "trrtttii", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt rrr", + "trt rtr", + "trt rtt", + "trt t", + "trt tit", + "trt trt", + "trt rrrr", + "trt rtrr", + "trt trrr", + "trt trrt", + "trt trt", + "trt ttit", + "trt tttr", + "trt tttt", + "trti", + "trtii", + "trtiii", + "trtiiiii", + "trtiiitr", + "trtiiitt", + "trtiirrt", + "trtiitir", + "trtiitrt", + "trtiittt", + "trtirrrt", + "trtirrtt", + "trtirtti", + "trtirttt", + "trtit", + "trtitirr", + "trtitrrr", + "trtitrrt", + "trtitt", + "trtitti", + "trtittit", + "trtittti", + "trtitttt", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt r", + "trtrrt t", + "trtrrtii", + "trtrrtir", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt tt", + "trtrti", + "trtrtiii", + "trtrtiit", + "trtrtirr", + "trtrtirt", + "trtrtitt", + "trtrtrr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rt", + "trtt t", + "trtt ttt", + "trtti", + "trttii", + "trttiiii", + "trttiiit", + "trttiitt", + "trttirrr", + "trttirtt", + "trttitii", + "trttitit", + "trttitrr", + "trttitrt", + "trttitti", + "trttittr", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrtii", + "trttrtrr", + "trttrtrt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttti i", + "trtttiii", + "trtttiit", + "trtttirt", + "trtttit", + "trtttiti", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt r", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt tt", + "tt r", + "tt t", + "tt ttt", + "tt irrr", + "tt rrr", + "tt t t", + "tt tr", + "tt trt", + "tt trtr", + "tt tt", + "tt tttt", + "tt ittt", + "tt rrrrr", + "tt rrrrt", + "tt rrrt", + "tt rrrtt", + "tt rrt", + "tt rrtrr", + "tt rrttt", + "tt rt", + "tt rt tr", + "tt rttrt", + "tt rtttr", + "tt rtttt", + "tt t", + "tt t t", + "tt t tt", + "tt t rr", + "tt trrrr", + "tt trttt", + "tt tt", + "tt tti", + "tt ttiii", + "tt ttrtt", + "tt tttii", + "tt tttrr", + "tt tttrt", + "tt tttt", + "tt tttti", + "tt ttttt", + "tti", + "tti itt", + "tti iiti", + "tti itt", + "tti ttt", + "ttii", + "ttii rr", + "ttii tr", + "ttiii", + "ttiii ii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirtr", + "ttiiiti", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrtr", + "ttiirrtt", + "ttiirtii", + "ttiirtir", + "ttiirtit", + "ttiirtrt", + "ttiirtt", + "ttiirtti", + "ttiit", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiir", + "ttiitiit", + "ttiitirr", + "ttiitirt", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtt", + "ttiitt", + "ttiitt i", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrr", + "ttirrrrr", + "ttirrrrt", + "ttirrrtt", + "ttirrt", + "ttirrtrt", + "ttirrtti", + "ttirrttr", + "ttirrttt", + "ttirt ti", + "ttirtitt", + "ttirtrrr", + "ttirtrrt", + "ttirtrtr", + "ttirtrtt", + "ttirtt", + "ttirttii", + "ttirttrr", + "ttirttrt", + "ttirttti", + "ttirtttt", + "ttit", + "ttit tti", + "ttit ttt", + "ttiti", + "ttitii r", + "ttitii t", + "ttitiii", + "ttitiiii", + "ttitiiir", + "ttitiiit", + "ttitiirt", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirrr", + "ttitirrt", + "ttitirt", + "ttitit", + "ttititii", + "ttititit", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrt", + "ttitrtrr", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitti", + "ttitti t", + "ttittiii", + "ttittiir", + "ttittiit", + "ttittirr", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitr", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrtir", + "ttrrrtit", + "ttrrrtr", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt tt", + "ttrrti", + "ttrrtiii", + "ttrrtit", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrttii", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt rrr", + "ttrt rrt", + "ttrt rtr", + "ttrtiii", + "ttrtiiii", + "ttrtiiir", + "ttrtiirt", + "ttrtiitt", + "ttrtirrr", + "ttrtirrt", + "ttrtirt", + "ttrtitt", + "ttrtittt", + "ttrtrr", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrtii", + "ttrtrtir", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt t", + "ttrttiii", + "ttrttiir", + "ttrttirr", + "ttrttirt", + "ttrttiti", + "ttrttitr", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt t", + "ttrtttii", + "ttrtttir", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt rt", + "ttt i", + "ttt iii", + "ttt rtr", + "ttt t", + "ttt t t", + "ttt tir", + "ttt trr", + "ttt ttt", + "ttt rrrr", + "ttt rtti", + "ttt t", + "ttt tiii", + "ttt trrt", + "ttt trtr", + "ttt trtt", + "ttt tt", + "ttt ttit", + "ttt ttti", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti tr", + "ttti iti", + "ttti itt", + "tttii", + "tttii ii", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiirt", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirtt", + "tttiit", + "tttiit t", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrt", + "tttirrti", + "tttirrtr", + "tttirrtt", + "tttirt", + "tttirtii", + "tttirtit", + "tttirttt", + "tttit", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirt", + "tttitit", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttr", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt i", + "tttrrt t", + "tttrrtii", + "tttrrtir", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt tt", + "tttrtiii", + "tttrtirr", + "tttrtirt", + "tttrtit", + "tttrtitr", + "tttrtrr", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtti", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt t", + "tttt ii", + "tttt rr", + "tttt t", + "tttt tt", + "tttt i", + "tttt iii", + "tttt rrr", + "tttt rrt", + "tttt rtt", + "tttt t", + "tttt tii", + "tttt tt", + "tttt ttr", + "tttt ttt", + "tttti", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitt", + "ttttirrr", + "ttttirtr", + "ttttirtt", + "ttttit", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttritt", + "ttttrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrti", + "ttttrtii", + "ttttrtit", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr26": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i t", + "i i", + "i ii", + "i ir", + "i it", + "i tr", + "i tt", + "i i", + "i iii", + "i irr", + "i irt", + "i it", + "i itt", + "i rrr", + "i rtt", + "i t", + "i trt", + "i ttt", + "i i", + "i ii", + "i iii", + "i iiii", + "i iirr", + "i iirt", + "i irrr", + "i itrr", + "i itrt", + "i itt", + "i itti", + "i ittt", + "i rttt", + "i ttrr", + "i tttr", + "i tttt", + "i i", + "i i iii", + "i i rrt", + "i ii", + "i iiiii", + "i iiiit", + "i iiirr", + "i iirrr", + "i iitrt", + "i iitt", + "i iitti", + "i iittt", + "i irrrr", + "i irrrt", + "i irrt", + "i irrtr", + "i irrtt", + "i irtrr", + "i irtrt", + "i irttr", + "i irttt", + "i it", + "i it tt", + "i itiii", + "i ititt", + "i itrrr", + "i itrrt", + "i itrtr", + "i itt", + "i itt t", + "i ittii", + "i ittrr", + "i ittrt", + "i ittti", + "i itttt", + "i rrrti", + "i rtrtt", + "i trrrr", + "i ttrrr", + "i ttt", + "i tttt", + "i ttttr", + "i ttttt", + "i i", + "i i itt", + "i i ttr", + "i i rrrt", + "i i rrtr", + "i i trrt", + "i i ttt", + "i ii", + "i iiii", + "i iiiii", + "i iiiiii", + "i iiiiir", + "i iiiiit", + "i iiiitr", + "i iiirrr", + "i iiittt", + "i iirrrr", + "i iirrtt", + "i iirtii", + "i iitrrr", + "i iittii", + "i iitttt", + "i irrrrr", + "i irrrrt", + "i irrrt", + "i irrrtt", + "i irrt", + "i irrtrr", + "i irrttt", + "i irt tt", + "i irtiit", + "i irtitr", + "i irtrtr", + "i irtrtt", + "i irtt", + "i irttrr", + "i irtttr", + "i it", + "i it rtt", + "i it trr", + "i itirtt", + "i itrirr", + "i itrrrr", + "i itrrrt", + "i itrtrr", + "i itrtt", + "i itrttt", + "i ittrtr", + "i ittt t", + "i itttii", + "i itttrr", + "i ittttr", + "i ittttt", + "i rrrrrr", + "i rrrrrt", + "i rrtrrr", + "i rtittt", + "i rtrrrr", + "i rtrrrt", + "i rtrtii", + "i t", + "i tittt", + "i trrrrr", + "i trrrrt", + "i trrtrr", + "i ttittt", + "i ttrrtt", + "i ttti", + "i tttrrr", + "i tttrtr", + "i ttttit", + "i ttttrr", + "i ttttrt", + "i tttttt", + "ii", + "ii i", + "ii iii", + "ii iiii", + "ii irrr", + "ii i", + "ii i ii", + "ii i iii", + "ii iiiii", + "ii iiitt", + "ii iit", + "ii rtttt", + "ii t", + "ii trrrr", + "ii ttttt", + "iii", + "iii i ii", + "iii iiii", + "iii iiir", + "iii iiit", + "iii irrr", + "iii ittt", + "iiii", + "iiii i", + "iiii i", + "iiii iii", + "iiii iir", + "iiii rrr", + "iiii rrt", + "iiii tti", + "iiiii", + "iiiii i", + "iiiii ii", + "iiiii ir", + "iiiii tt", + "iiiiii", + "iiiiii i", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiitii", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrti", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirti", + "iiiirtii", + "iiiirtir", + "iiiirtrr", + "iiiirtrt", + "iiiirtti", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitirt", + "iiiititi", + "iiiititr", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrti", + "iiiitrtt", + "iiiitt", + "iiiitti", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrti", + "iiirrtrr", + "iiirrtti", + "iiirt", + "iiirti", + "iiirtiit", + "iiirtrtt", + "iiirttii", + "iiirttrt", + "iiirttti", + "iiirtttt", + "iiit", + "iiit tr", + "iiit tt", + "iiit rrr", + "iiit rrt", + "iiit tt", + "iiiti", + "iiiti ii", + "iiitii", + "iiitiii", + "iiitiiii", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitt", + "iiitirrr", + "iiitit", + "iiititii", + "iiititit", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrtrr", + "iiitrtrt", + "iiitrtt", + "iiitrttr", + "iiitrttt", + "iiitt", + "iiitt t", + "iiitti", + "iiittiii", + "iiittiir", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtt", + "iiittt", + "iiittti", + "iiitttir", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrti", + "iirrrrtr", + "iirrrt", + "iirrrt t", + "iirrrtit", + "iirrrtrr", + "iirrrtrt", + "iirrrtti", + "iirrrttr", + "iirrrttt", + "iirrt", + "iirrtiii", + "iirrtiir", + "iirrtrrr", + "iirrtrrt", + "iirrtrt", + "iirrtrtr", + "iirrtrtt", + "iirrttit", + "iirrttrr", + "iirrttrt", + "iirrtttr", + "iirrtttt", + "iirt", + "iirt iit", + "iirt rrr", + "iirtiii", + "iirtirtr", + "iirtitii", + "iirtrrrr", + "iirtrrrt", + "iirtrrt", + "iirtrrtr", + "iirtrrtt", + "iirtrtti", + "iirtt", + "iirttrrr", + "iirttt", + "iirtttit", + "iirtttt", + "iirtttti", + "iirttttr", + "iirttttt", + "iit", + "iit i", + "iit rrrr", + "iit rtt", + "iit t", + "iit tiii", + "iit trti", + "iiti", + "iitii", + "iitii it", + "iitiiii", + "iitiiiii", + "iitiiiir", + "iitiiiit", + "iitiiirt", + "iitiiiti", + "iitiiitt", + "iitiirrr", + "iitiirtr", + "iitiitii", + "iitiitit", + "iitiitti", + "iitiittr", + "iitiittt", + "iitirrrt", + "iitirrt", + "iitirttt", + "iitit", + "iititi", + "iititi i", + "iititiii", + "iititiit", + "iitititi", + "iitititt", + "iititrti", + "iititrtt", + "iitittit", + "iitittt", + "iitittti", + "iititttr", + "iititttt", + "iitrirrr", + "iitrrrrr", + "iitrrrrt", + "iitrrrt", + "iitrrrtr", + "iitrrrtt", + "iitrrt", + "iitrrti", + "iitrrtrt", + "iitrrttr", + "iitrrttt", + "iitrt t", + "iitrtrrr", + "iitrtrrt", + "iitrtrtr", + "iitrtrtt", + "iitrtt", + "iitrttrr", + "iitrttrt", + "iitrtttt", + "iitt", + "iitt ttt", + "iitti", + "iittii", + "iittiiii", + "iittiiit", + "iittiiti", + "iittiitt", + "iittirrt", + "iittitii", + "iittitit", + "iittitrr", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrtt", + "iittrtrr", + "iittrtrt", + "iittrtt", + "iittrtti", + "iittrttt", + "iittt", + "iittt tt", + "iitttiii", + "iitttiit", + "iitttirr", + "iitttiti", + "iitttitr", + "iitttrrr", + "iitttrrt", + "iitttrti", + "iitttrtr", + "iitttrtt", + "iitttt", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrti", + "irrrrtii", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrt rr", + "irrrt rt", + "irrrt t", + "irrrti", + "irrrtiii", + "irrrtiir", + "irrrtirr", + "irrrtiti", + "irrrtrrr", + "irrrtrt", + "irrrtt", + "irrrttii", + "irrrttir", + "irrrttrr", + "irrrttrt", + "irrrttt", + "irrrttti", + "irrrtttr", + "irrrtttt", + "irrt", + "irrt rr", + "irrt irt", + "irrt rrr", + "irrt t r", + "irrtiiit", + "irrtirrt", + "irrtittr", + "irrtrrrr", + "irrtrrtr", + "irrtrrtt", + "irrtrt", + "irrtrtii", + "irrtrtrr", + "irrtrtrt", + "irrtrttr", + "irrtrttt", + "irrtt", + "irrttiii", + "irrttiit", + "irrttirt", + "irrttrrr", + "irrttrrt", + "irrttrtt", + "irrtttrr", + "irrtttrt", + "irrtttt", + "irrttttr", + "irrttttt", + "irt", + "irt rrrt", + "irt t", + "irti", + "irtiii", + "irtiiiii", + "irtiirti", + "irtiitrr", + "irtiitti", + "irtiittr", + "irtirrrr", + "irtirrti", + "irtit", + "irtititt", + "irtitrrt", + "irtittii", + "irtittrt", + "irtitttt", + "irtrrrrr", + "irtrrrrt", + "irtrrrtr", + "irtrrrtt", + "irtrrt", + "irtrrtrr", + "irtrrtrt", + "irtrrttr", + "irtrtrrr", + "irtrtrrt", + "irtrtrti", + "irtrttrr", + "irtrttrt", + "irtrtttr", + "irtt", + "irttiiit", + "irttirrt", + "irttitt", + "irttittt", + "irttrrrr", + "irttrttr", + "irttrttt", + "irttt", + "irttt tt", + "irttti", + "irtttii", + "irtttiii", + "irtttiit", + "irtttrrr", + "irtttrrt", + "irtttrt", + "irtttrtr", + "irtttrtt", + "irtttt", + "irtttti", + "irttttii", + "irtttttt", + "it", + "it iii", + "it trrr", + "it tt t", + "it iiiii", + "it irrrr", + "it rrrt", + "it rttrt", + "it t", + "it tii", + "it ttitt", + "it ttt", + "iti", + "iti ttti", + "itii", + "itii iit", + "itii trt", + "itiii", + "itiiii", + "itiiiiii", + "itiiiiit", + "itiiiirr", + "itiiiit", + "itiiiiti", + "itiiiitt", + "itiiirrr", + "itiiit", + "itiiitii", + "itiiitit", + "itiiitrr", + "itiiitt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirt", + "itiirtii", + "itiirtt", + "itiit", + "itiititr", + "itiittii", + "itiittt", + "itiittti", + "itiitttr", + "itiitttt", + "itirrrrr", + "itirrrt", + "itirrrtt", + "itirrtii", + "itirrtrr", + "itirrttt", + "itirtirr", + "itirttrr", + "itirtttt", + "itit", + "itit rrr", + "ititi", + "ititii", + "ititiiit", + "ititiirr", + "ititiit", + "ititiiti", + "ititirti", + "itititit", + "itititt", + "ititittt", + "ititrrrr", + "ititrrrt", + "ititrrtt", + "ititrt", + "ititrttt", + "ititt", + "itittiii", + "itittiit", + "itittiti", + "itittitt", + "itittrtt", + "itittt", + "ititttit", + "ititttrt", + "ititttti", + "itittttt", + "itrrrrrr", + "itrrrrrt", + "itrrrrti", + "itrrrrtr", + "itrrrrtt", + "itrrrtii", + "itrrrtrr", + "itrrrtrt", + "itrrrtti", + "itrrrttt", + "itrrt", + "itrrt rr", + "itrrtiii", + "itrrtrrr", + "itrrtrt", + "itrrtrti", + "itrrtt", + "itrrttir", + "itrrttrr", + "itrrtttt", + "itrt", + "itrt rt", + "itrt rrr", + "itrt rrt", + "itrt ttt", + "itrtiiti", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrti", + "itrtrtrr", + "itrtrtrt", + "itrtrtt", + "itrtt", + "itrttirr", + "itrttitt", + "itrttrrr", + "itrttrrt", + "itrttrtr", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt t t", + "itt iiit", + "itt itii", + "itt rrrr", + "itt rrtt", + "itt tttr", + "itt tttt", + "itti", + "ittii", + "ittiiii", + "ittiiiii", + "ittiiiit", + "ittiiirr", + "ittiiit", + "ittiiiti", + "ittiiitr", + "ittiiitt", + "ittiirt", + "ittiit", + "ittiitii", + "ittiitit", + "ittiitrt", + "ittiittt", + "ittirrrr", + "ittirrti", + "ittirrtt", + "ittirtt", + "ittirtti", + "ittirttt", + "ittit", + "ittitiii", + "ittitiit", + "ittititt", + "ittitrrr", + "ittitrt", + "ittitt", + "ittitti", + "ittittii", + "ittittrr", + "ittittti", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrt", + "ittrrrti", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrtrr", + "ittrrtrt", + "ittrrttr", + "ittrrttt", + "ittrt", + "ittrtiii", + "ittrtirr", + "ittrtiti", + "ittrtrrr", + "ittrtrrt", + "ittrtrtr", + "ittrtrtt", + "ittrtt", + "ittrttrr", + "ittrttrt", + "ittrtttr", + "ittrtttt", + "ittt", + "ittt ii", + "ittt t", + "ittt t", + "ittt ttt", + "ittti", + "itttii", + "itttiii", + "itttiiii", + "itttiiit", + "itttiitt", + "itttirrt", + "itttit", + "itttitii", + "itttitit", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrtrr", + "itttrtrt", + "itttrtt", + "itttrttr", + "itttrttt", + "itttt", + "itttt t", + "itttti", + "ittttiii", + "ittttiit", + "ittttiti", + "ittttitt", + "ittttrrr", + "ittttrrt", + "ittttrt", + "ittttrti", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "rirrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt i", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt r", + "rrrrt t", + "rrrrt i", + "rrrrt ii", + "rrrrt ir", + "rrrrt it", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt ti", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt t", + "rrrt ii", + "rrrt ir", + "rrrt rr", + "rrrt rt", + "rrrt t", + "rrrt ii", + "rrrt iii", + "rrrt iir", + "rrrt irr", + "rrrt iti", + "rrrt itr", + "rrrt itt", + "rrrt rrr", + "rrrt rrt", + "rrrt rti", + "rrrt rtr", + "rrrt rtt", + "rrrt t", + "rrrt tii", + "rrrt tit", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt tti", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrtii", + "rrrtii i", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtr", + "rrrtirtt", + "rrrtit", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt r", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt ii", + "rrrtt rr", + "rrrtt rt", + "rrrtt t", + "rrrtt tr", + "rrrtt tt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt r", + "rrrttt t", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt rr", + "rrt irr", + "rrt rrr", + "rrt rt", + "rrt tii", + "rrt trr", + "rrt tt", + "rrt ttr", + "rrt ii", + "rrt iiir", + "rrt irrr", + "rrt irrt", + "rrt it", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt", + "rrt rtrr", + "rrt rtrt", + "rrt rtt", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt tiir", + "rrt tirt", + "rrt trrr", + "rrt trrt", + "rrt trtt", + "rrt ttrr", + "rrt ttti", + "rrt tttr", + "rrt tttt", + "rrti", + "rrti iir", + "rrti itr", + "rrti ttt", + "rrtii", + "rrtii t", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiirr", + "rrtiiirt", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirti", + "rrtiirtr", + "rrtiirtt", + "rrtiit", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitt", + "rrtiitti", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirt r", + "rrtirtii", + "rrtirtir", + "rrtirtit", + "rrtirtrr", + "rrtirtrt", + "rrtirtt", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtit rt", + "rrtitiii", + "rrtitiir", + "rrtitiit", + "rrtitirr", + "rrtitit", + "rrtititi", + "rrtititt", + "rrtitrrr", + "rrtitrrt", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitrtt", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittt", + "rrtitttt", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt t", + "rrtrt rr", + "rrtrt rt", + "rrtrt tr", + "rrtrt tt", + "rrtrti", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtitr", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtti", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt ii", + "rrtt rr", + "rrtt tt", + "rrtt rrr", + "rrtt rrt", + "rrtt trr", + "rrtt ttr", + "rrtti", + "rrttii", + "rrttii r", + "rrttiii", + "rrttiiii", + "rrttiirt", + "rrttiit", + "rrttiiti", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttittr", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt ii", + "rrttt rr", + "rrttt tt", + "rrttti", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt ii", + "rt rr", + "rt rt", + "rt tr", + "rt i", + "rt itrr", + "rt rrrr", + "rt rrrt", + "rt t", + "rt trt", + "rt trtr", + "rt i", + "rt iirrr", + "rt irrrr", + "rt it ii", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrti", + "rt rrrtr", + "rt rrtir", + "rt rrtrr", + "rt rrtrt", + "rt rrtt", + "rt rrttt", + "rt rt r", + "rt rti", + "rt rtirr", + "rt rtrrt", + "rt rtrtr", + "rt rttrr", + "rt t", + "rt t ii", + "rt t rr", + "rt t rt", + "rt t t", + "rt t ti", + "rt t rrr", + "rt t rti", + "rt t t", + "rt t trr", + "rt ti", + "rt trrrr", + "rt trrrt", + "rt trrtr", + "rt trtrr", + "rt ttrrr", + "rt ttrrt", + "rt ttrt", + "rt tttrr", + "rt tttt", + "rt tttti", + "rt ttttt", + "rti", + "rtii", + "rtii tir", + "rtiii", + "rtiii rr", + "rtiii tt", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiiti", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirt", + "rtiiirtr", + "rtiiirtt", + "rtiiit", + "rtiiitii", + "rtiiitrr", + "rtiirrrr", + "rtiirrt", + "rtiirrtt", + "rtiirti", + "rtiirtir", + "rtiirtit", + "rtiirtt", + "rtiirtti", + "rtiit", + "rtiitii", + "rtiitiii", + "rtiitiir", + "rtiitrrr", + "rtiitrtt", + "rtiittii", + "rtiittrr", + "rtiittt", + "rtiittti", + "rtiitttt", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrtt", + "rtirrt", + "rtirrtii", + "rtirrtrt", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirtitt", + "rtirtrrr", + "rtirtrrt", + "rtirtrt", + "rtirtrtt", + "rtirtti", + "rtirttii", + "rtirttrr", + "rtirtttt", + "rtit", + "rtit irr", + "rtit rrr", + "rtiti", + "rtitiiii", + "rtitiiir", + "rtitiirr", + "rtitiitr", + "rtititii", + "rtititir", + "rtitittr", + "rtitrrrr", + "rtitrrtr", + "rtitrrtt", + "rtitrt", + "rtitrtii", + "rtitrtir", + "rtitrtrr", + "rtitrtti", + "rtitt", + "rtittiii", + "rtittiit", + "rtittirr", + "rtittit", + "rtittitr", + "rtittitt", + "rtittrrr", + "rtittrrt", + "rtittt", + "rtitttii", + "rtitttrr", + "rtitttti", + "rtittttr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrt t", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt rr", + "rtrrt rt", + "rtrrt tr", + "rtrrti", + "rtrrtii", + "rtrrtiii", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtiti", + "rtrrtitt", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt t", + "rtrt ii", + "rtrt it", + "rtrt rrr", + "rtrt rrt", + "rtrt rt", + "rtrt rti", + "rtrt rtr", + "rtrt rtt", + "rtrt trr", + "rtrt trt", + "rtrt tti", + "rtrt ttr", + "rtrt ttt", + "rtrti", + "rtrtii r", + "rtrtiiii", + "rtrtiiit", + "rtrtiit", + "rtrtiiti", + "rtrtirrr", + "rtrtirrt", + "rtrtirtr", + "rtrtit", + "rtrtitit", + "rtrtitrr", + "rtrtittr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt r", + "rtrtrti", + "rtrtrtii", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt t", + "rtrtt tr", + "rtrtti", + "rtrtti t", + "rtrttiii", + "rtrttiir", + "rtrttiit", + "rtrttirr", + "rtrttirt", + "rtrttiti", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt t", + "rtt irrt", + "rtt rrrr", + "rtt rrrt", + "rtt rrtr", + "rtt rrtt", + "rtt rtrr", + "rtt rtrt", + "rtt rttr", + "rtt rttt", + "rtt t", + "rtt trt", + "rtt trtt", + "rtt ttrr", + "rtt ttti", + "rtt tttt", + "rtti", + "rtti rrr", + "rtti ttt", + "rttii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiirr", + "rttiiiti", + "rttiiitr", + "rttiirrr", + "rttiirt", + "rttiirtr", + "rttiit", + "rttiitt", + "rttiitti", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrt", + "rttirrtr", + "rttirrtt", + "rttirt", + "rttirtrr", + "rttirtrt", + "rttirttr", + "rttirttt", + "rttit", + "rttiti", + "rttitiii", + "rttitirt", + "rttititt", + "rttitrrr", + "rttitrrt", + "rttitrtt", + "rttitt", + "rttittii", + "rttittit", + "rttittrr", + "rttittrt", + "rttitttt", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt r", + "rttrrtir", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt r", + "rttrt tt", + "rttrtiii", + "rttrtiit", + "rttrtirt", + "rttrtitr", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtti", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt t", + "rttt rr", + "rttt i", + "rttt iir", + "rttt rrr", + "rttt rrt", + "rttt t", + "rttt trr", + "rttt trt", + "rttt tt", + "rttt ttt", + "rttti", + "rtttiii", + "rtttiiii", + "rtttiiit", + "rtttirrr", + "rtttirrt", + "rtttit", + "rtttitrr", + "rtttitrt", + "rtttitti", + "rtttittr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrt t", + "rtttrti", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt rr", + "rtttt rt", + "rtttt t", + "rtttt tr", + "rtttt tt", + "rtttti", + "rtttti t", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt r", + "rttttti", + "rtttttii", + "rtttttir", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t t", + "t i", + "t ii", + "t rr", + "t rt", + "t t", + "t ti", + "t tr", + "t tt", + "t ii", + "t iii", + "t itt", + "t t", + "t i", + "t irrr", + "t ittt", + "t rrrr", + "t trrt", + "t trtr", + "t tti", + "t iiiii", + "t iiirr", + "t iirrr", + "t iirt", + "t iitii", + "t irrrr", + "t irrtr", + "t irtrr", + "t it ii", + "t itrrt", + "t rrrrr", + "t rrrrt", + "t rrrti", + "t rrrtr", + "t rrrtt", + "t rrti", + "t rrtrr", + "t rrtrt", + "t rrtt", + "t rrttt", + "t rtt", + "t rttit", + "t rttt", + "t t", + "t t rrr", + "t trrrr", + "t trrrt", + "t trrtt", + "t trtt", + "t trtti", + "t tt", + "t tt tt", + "t ttrrr", + "t ttt", + "t ttttr", + "t ttttt", + "t i", + "t i rtt", + "t ii", + "t iii", + "t iiiiii", + "t iirrrt", + "t iit", + "t iittt", + "t irrrrr", + "t irrrti", + "t irtrtr", + "t irtttt", + "t it ii", + "t ititii", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrti", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrt r", + "t rrrtrr", + "t rrrtrt", + "t rrrtt", + "t rrrtti", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrtrrr", + "t rrtrrt", + "t rrtrtr", + "t rrtt", + "t rrttrt", + "t rrttt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt t", + "t rtiiii", + "t rtirrt", + "t rtrrrr", + "t rtrrrt", + "t rtrrti", + "t rtrrtr", + "t rtrrtt", + "t rtrt", + "t rtrtrr", + "t rtrtt", + "t rtrttr", + "t rtrttt", + "t rtt", + "t rttrrr", + "t rttrtt", + "t rttt", + "t rtttt", + "t rttttr", + "t rttttt", + "t t", + "t t t", + "t t rtr", + "t t ttt", + "t t trrt", + "t t ttt", + "t ti", + "t tiiiii", + "t tiiiit", + "t tiirrt", + "t tiirtt", + "t tit", + "t titt", + "t titttt", + "t trrrrr", + "t trrrrt", + "t trrrt", + "t trrrtr", + "t trrt r", + "t trrtrr", + "t trrtrt", + "t trrtt", + "t trrttt", + "t trt", + "t trtiii", + "t trtrrr", + "t trtrrt", + "t trtrtr", + "t trtt", + "t trttt", + "t trtttt", + "t tt", + "t tt tt", + "t tt ttt", + "t ttiiii", + "t ttirrr", + "t ttrrrr", + "t ttrrtr", + "t ttrrtt", + "t ttrtrr", + "t ttrtrt", + "t ttt", + "t tttiii", + "t tttitr", + "t tttrrr", + "t tttrrt", + "t tttrtr", + "t tttrtt", + "t tttt", + "t tttt t", + "t ttttii", + "t ttttrr", + "t ttttrt", + "t ttttt", + "t tttttr", + "t tttttt", + "ti", + "ti iiii", + "ti tttt", + "ti itrrr", + "ti t", + "ti tttti", + "tii", + "tii iitt", + "tii irtr", + "tii itit", + "tiii", + "tiii iii", + "tiii irr", + "tiiii", + "tiiiii", + "tiiiii i", + "tiiiii t", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirtt", + "tiiiit", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrt", + "tiiirt", + "tiiirt t", + "tiiirtii", + "tiiirtrr", + "tiiirtrt", + "tiiirtti", + "tiiirttr", + "tiiit", + "tiiit tt", + "tiiiti", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitirr", + "tiiitirt", + "tiiitrrr", + "tiiitt", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrti", + "tiirrrtr", + "tiirrrtt", + "tiirrt", + "tiirrt r", + "tiirrttt", + "tiirt", + "tiirtii", + "tiirtirr", + "tiirtitr", + "tiirtrrr", + "tiirtrti", + "tiirtrtr", + "tiirttrr", + "tiirttt", + "tiirtttr", + "tiit", + "tiit rt", + "tiit rtr", + "tiit trt", + "tiit ttt", + "tiiti", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirr", + "tiitiitt", + "tiitirrr", + "tiititii", + "tiititit", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrti", + "tiitrtii", + "tiitrtrt", + "tiitrttr", + "tiitrttt", + "tiitt", + "tiitt rr", + "tiitti", + "tiittiii", + "tiittiir", + "tiittiti", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrtt", + "tiittt", + "tiitttii", + "tiitttit", + "tiitttrr", + "tiitttrt", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrt r", + "tirrrtii", + "tirrrtir", + "tirrrtrr", + "tirrrtrt", + "tirrrtt", + "tirrrttt", + "tirrt tt", + "tirrtirr", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrti", + "tirrtt", + "tirrttit", + "tirrttrr", + "tirrtttr", + "tirrtttt", + "tirt rrr", + "tirtiirt", + "tirtirrr", + "tirtrrrr", + "tirtrrrt", + "tirtrrtr", + "tirtrtii", + "tirtrtrr", + "tirtrtrt", + "tirtrtt", + "tirtrttt", + "tirtt", + "tirttiii", + "tirttrtt", + "tirtttit", + "tirtttrt", + "tirttttr", + "tirttttt", + "tit", + "tit rrrr", + "tit rrt", + "tit trtr", + "tit tttt", + "titi", + "titii", + "titiiii", + "titiiiii", + "titiiiit", + "titiiit", + "titiiiti", + "titiiitt", + "titiirrr", + "titiirrt", + "titiirtt", + "titiitit", + "titiitrt", + "titiitt", + "titiitti", + "titiittt", + "titirrrr", + "titirrtt", + "titit", + "tititiii", + "tititirr", + "titititi", + "titititt", + "tititt", + "titittii", + "titittit", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrtt", + "titrrtrr", + "titrrtrt", + "titrt", + "titrtiii", + "titrtitt", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrtttt", + "titt", + "titt rtr", + "tittii", + "tittiiii", + "tittiiti", + "tittiitt", + "tittirrr", + "tittit", + "tittiti", + "tittitii", + "tittitit", + "tittitrr", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrti", + "tittrrtt", + "tittrtrr", + "tittrtrt", + "tittrtti", + "tittrttr", + "tittt", + "tittti", + "titttiii", + "titttiti", + "titttitt", + "titttrrr", + "titttrtr", + "titttrtt", + "titttt", + "titttt t", + "tittttii", + "tittttit", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "trirrrrt", + "trirtrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt t", + "trrrrti", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt i", + "trrrt rr", + "trrrt t", + "trrrt tr", + "trrrt tt", + "trrrti", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtitr", + "trrrtitt", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt r", + "trrrtt t", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt t", + "trrt t", + "trrt tr", + "trrt tt", + "trrt it", + "trrt rrr", + "trrt rrt", + "trrt rtr", + "trrt rtt", + "trrt t", + "trrt trr", + "trrt trt", + "trrt ttr", + "trrt ttt", + "trrti", + "trrtiii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiit", + "trrtiiti", + "trrtiitr", + "trrtiitt", + "trrtirrr", + "trrtirrt", + "trrtirt", + "trrtirti", + "trrtirtr", + "trrtirtt", + "trrtit", + "trrtitit", + "trrtitti", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrtir", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt r", + "trrtt tt", + "trrtti", + "trrttiii", + "trrttirr", + "trrttirt", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt rr", + "trt iiii", + "trt itti", + "trt rrrr", + "trt rrtr", + "trt rtrr", + "trt t rr", + "trt tiii", + "trt trrt", + "trt trt", + "trt trtr", + "trt trtt", + "trt tttt", + "trti", + "trtii", + "trtiiii", + "trtiiiii", + "trtiiirr", + "trtiiiti", + "trtiirrr", + "trtiirti", + "trtiit", + "trtiitii", + "trtiittr", + "trtirrrr", + "trtirrrt", + "trtirrti", + "trtirrtr", + "trtirtrr", + "trtit", + "trtitiii", + "trtitirr", + "trtititi", + "trtitrrr", + "trtitrt", + "trtitt", + "trtittrr", + "trtitttt", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt t", + "trtrrtii", + "trtrrtir", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt r", + "trtrt ii", + "trtrt tr", + "trtrtiir", + "trtrtirr", + "trtrtirt", + "trtrtitt", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrti", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtt r", + "trtrttii", + "trtrttit", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rr", + "trtt iii", + "trtt it", + "trtt rrr", + "trtt rtr", + "trtt rtt", + "trtt trr", + "trtt trt", + "trtt ttt", + "trttii", + "trttiiii", + "trttiirt", + "trttiiti", + "trttirrr", + "trttirrt", + "trttirtr", + "trttirtt", + "trttitii", + "trttitrr", + "trttitt", + "trttittr", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt r", + "trttrti", + "trttrtit", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttt rr", + "trttt tt", + "trtttiir", + "trtttiit", + "trtttirr", + "trtttirt", + "trtttiti", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt t", + "trtttti", + "trttttii", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt t", + "tt ii", + "tt iii", + "tt itt", + "tt rrr", + "tt rtr", + "tt trt", + "tt ttt", + "tt itrr", + "tt itt", + "tt rtrt", + "tt rttt", + "tt trrt", + "tt ttrr", + "tt ttt", + "tt tttt", + "tt i", + "tt iitti", + "tt irrrr", + "tt itirr", + "tt itttt", + "tt rrrrr", + "tt rrrrt", + "tt rrrtt", + "tt rrtrr", + "tt rrtrt", + "tt rrttt", + "tt rtrrr", + "tt rtrrt", + "tt rtrtr", + "tt rttrr", + "tt t", + "tt t t", + "tt t rrt", + "tt tiiit", + "tt titrr", + "tt trrrr", + "tt trrrt", + "tt trrtr", + "tt trtit", + "tt trtrr", + "tt trtrt", + "tt trtti", + "tt trttr", + "tt trttt", + "tt tt", + "tt ttrrt", + "tt ttrtr", + "tt ttt", + "tt tttii", + "tt tttrr", + "tt tttrt", + "tt ttttr", + "tt ttttt", + "tti", + "tti i", + "tti it", + "tti rrrr", + "tti rtrt", + "tti t", + "tti tttr", + "tti tttt", + "ttii", + "ttii iii", + "ttii rtr", + "ttiii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirt", + "ttiiirti", + "ttiiirtt", + "ttiiit", + "ttiiit i", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrtr", + "ttiirtrr", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiitiii", + "ttiitiit", + "ttiititi", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrt", + "ttiitrtt", + "ttiitt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrtr", + "ttirrt r", + "ttirrtii", + "ttirrtit", + "ttirrtrr", + "ttirrtrt", + "ttirrttt", + "ttirtiii", + "ttirtrrr", + "ttirtrtt", + "ttirttrt", + "ttirttti", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit t", + "ttit itr", + "ttiti", + "ttiti rt", + "ttitii", + "ttitiiii", + "ttitiiir", + "ttitiiit", + "ttitiirt", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitirrr", + "ttitirrt", + "ttitirtt", + "ttitit", + "ttititit", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrrt", + "ttitrrtr", + "ttitrrtt", + "ttitrt t", + "ttitrtrt", + "ttitrtti", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttittii", + "ttittiii", + "ttittiit", + "ttittirt", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrt r", + "ttrrrt t", + "ttrrrti", + "ttrrrtii", + "ttrrrtir", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt rr", + "ttrrt rt", + "ttrrt t", + "ttrrtiii", + "ttrrtiit", + "ttrrtirr", + "ttrrtirt", + "ttrrtitr", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrti", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt tt", + "ttrt rrr", + "ttrt rtr", + "ttrt rtt", + "ttrt trr", + "ttrt tt", + "ttrti", + "ttrtiiii", + "ttrtiirr", + "ttrtiitt", + "ttrtirrr", + "ttrtirrt", + "ttrtit r", + "ttrtitrr", + "ttrtitt", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrti", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrt t", + "ttrtrti", + "ttrtrtii", + "ttrtrtir", + "ttrtrtit", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrtti", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt rr", + "ttrtt tr", + "ttrtt tt", + "ttrtti r", + "ttrttiii", + "ttrttiir", + "ttrttiit", + "ttrttirr", + "ttrttirt", + "ttrttiti", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrt", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt t", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt ii", + "ttt iti", + "ttt rrr", + "ttt t", + "ttt trr", + "ttt ttr", + "ttt ttt", + "ttt iiii", + "ttt iiit", + "ttt iitt", + "ttt rrrr", + "ttt rrti", + "ttt rrtr", + "ttt rrtt", + "ttt rtrr", + "ttt rtrt", + "ttt trrr", + "ttt trrt", + "ttt trtr", + "ttt tt", + "ttt ttrr", + "ttt ttrt", + "ttt ttt", + "ttt tttr", + "ttt tttt", + "ttti", + "ttti t", + "ttti iii", + "ttti tit", + "ttti tt", + "tttii", + "tttii ti", + "tttii tt", + "tttiii", + "tttiii t", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiit", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiiti", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrtr", + "tttirrtt", + "tttirtii", + "tttirtir", + "tttirtit", + "tttirtrr", + "tttirtrt", + "tttirttr", + "tttirttt", + "tttit", + "tttit t", + "tttiti", + "tttitiii", + "tttitiir", + "tttitiit", + "tttitirt", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittit", + "tttittrr", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrt r", + "tttrrti", + "tttrrtii", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt rr", + "tttrt rt", + "tttrt tr", + "tttrt tt", + "tttrti", + "tttrtiit", + "tttrtit", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrtt r", + "tttrtt t", + "tttrtti", + "tttrttii", + "tttrttir", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt r", + "tttt rr", + "tttt rt", + "tttt tt", + "tttt iii", + "tttt irr", + "tttt rrr", + "tttt rrt", + "tttt rti", + "tttt rtr", + "tttt rtt", + "tttt t", + "tttt t r", + "tttt trr", + "tttt trt", + "tttt tt", + "tttt tti", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti tt", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirtt", + "ttttit", + "ttttitii", + "ttttitir", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrtii", + "ttttrtit", + "ttttrtri", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt ii", + "ttttt rr", + "ttttt rt", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "ttttti t", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt i", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr27": [ + "-1", + "-2", + "-6", + "i", + "i i", + "i ii", + "i rrrt", + "i iiiii", + "i trrtt", + "i ttttt", + "i i", + "i ii", + "i iii", + "i iiiii", + "i iiiiii", + "i iiirtt", + "i rrtrtr", + "i rttit", + "ii", + "ii i", + "ii t", + "ii ii", + "ii ii", + "ii i", + "ii iii", + "ii iiiii", + "ii itiit", + "ii rrttt", + "ii tiiii", + "iii", + "iii iii", + "iii iiii", + "iii rrrr", + "iii tttr", + "iii tttt", + "iiii", + "iiii iii", + "iiiii", + "iiiii ii", + "iiiii ir", + "iiiii tt", + "iiiiii", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiirr", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiiti", + "iiiiitii", + "iiiiitir", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrtr", + "iiiirrtt", + "iiiirt", + "iiiirtii", + "iiiirtrr", + "iiiirtrt", + "iiiirtt", + "iiiirtti", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiir", + "iiiitiit", + "iiiitirr", + "iiiitirt", + "iiiitit", + "iiiititi", + "iiiititr", + "iiiititt", + "iiiitrrr", + "iiiitrrt", + "iiiitrt", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtir", + "iiirrtit", + "iiirrtrr", + "iiirrtt", + "iiirrttt", + "iiirt", + "iiirt tr", + "iiirti", + "iiirtiii", + "iiirtirr", + "iiirtrrr", + "iiirtrtr", + "iiirtt", + "iiirttii", + "iiirttir", + "iiirttrt", + "iiirtttr", + "iiit", + "iiit tii", + "iiit tt", + "iiiti", + "iiitiii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitit", + "iiititii", + "iiititit", + "iiititrr", + "iiititt", + "iiititti", + "iiitittt", + "iiitrrr", + "iiitrrrr", + "iiitrrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrtit", + "iiitrtrr", + "iiitrtrt", + "iiitrtti", + "iiitrttt", + "iiitt", + "iiitti", + "iiittiii", + "iiittitr", + "iiittitt", + "iiittrrr", + "iiittrrt", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiitttii", + "iiitttir", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrr", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrt r", + "iirrrti", + "iirrrtii", + "iirrrtrr", + "iirrrtt", + "iirrrtti", + "iirrrttr", + "iirrrttt", + "iirrt", + "iirrtiii", + "iirrtrrr", + "iirrtrtt", + "iirrtt", + "iirrttii", + "iirrttit", + "iirt", + "iirti", + "iirtiiii", + "iirtiiir", + "iirtiiit", + "iirtiirr", + "iirtirrr", + "iirtrrrr", + "iirtrrti", + "iirtrrtr", + "iirtrtrr", + "iirtrttr", + "iirtt", + "iirtti i", + "iirttiit", + "iirttrrr", + "iirttt", + "iirtttrr", + "iirttttt", + "iit", + "iiti", + "iiti t", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiit", + "iitiiiti", + "iitiiitr", + "iitiiitt", + "iitiirrr", + "iitiirti", + "iitiitii", + "iitiitit", + "iitiitti", + "iitiittr", + "iitiittt", + "iitirrrr", + "iitirtt", + "iitirttt", + "iitit", + "iititiii", + "iititit", + "iitititi", + "iitititt", + "iititrrr", + "iititrrt", + "iititrtt", + "iitittii", + "iitittit", + "iitittt", + "iitittti", + "iititttr", + "iititttt", + "iitr", + "iitrrrrr", + "iitrrrrt", + "iitrrrtr", + "iitrrrtt", + "iitrrtrr", + "iitrrttr", + "iitrrttt", + "iitrtiir", + "iitrtiti", + "iitrtrrt", + "iitrtt", + "iitrttii", + "iitrttt", + "iitrttti", + "iitrtttr", + "iitrtttt", + "iitt", + "iitt tt", + "iitti", + "iittii", + "iittiii", + "iittiiii", + "iittiiir", + "iittiiit", + "iittiirr", + "iittiiti", + "iittiitt", + "iittit", + "iittiti", + "iittitii", + "iittitit", + "iittitrt", + "iittitt", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrti", + "iittrrtt", + "iittrtrt", + "iittrttr", + "iittrttt", + "iittt", + "iittti", + "iitttiii", + "iitttiit", + "iitttiti", + "iitttitt", + "iitttrrr", + "iitttrrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttit", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "irrrrrrr", + "irrrrrrt", + "irrrrrti", + "irrrrrtt", + "irrrrt", + "irrrrtii", + "irrrrtrr", + "irrrrtrt", + "irrrrtt", + "irrrrttr", + "irrrrttt", + "irrrt", + "irrrti", + "irrrtiii", + "irrrtiir", + "irrrtrrr", + "irrrtrtr", + "irrrtt", + "irrrtt r", + "irrrttii", + "irrrttrr", + "irrrttrt", + "irrrttti", + "irrrtttr", + "irrrtttt", + "irrt", + "irrtiiii", + "irrtiirr", + "irrtitit", + "irrtrrr", + "irrtrrrr", + "irrtrrrt", + "irrtrrtt", + "irrtrt", + "irrtt", + "irrttii", + "irrttiii", + "irrttit", + "irrttrrt", + "irrttrtr", + "irrtttrt", + "irrtttt", + "irrtttti", + "irrttttr", + "irt", + "irti", + "irtii", + "irtiiiii", + "irtiiiit", + "irtiiirr", + "irtiirrr", + "irtiirtt", + "irtiittt", + "irtirrrr", + "irtirrtt", + "irtittrt", + "irtrrrrr", + "irtrrrrt", + "irtrrrti", + "irtrrtti", + "irtrrttt", + "irtrti", + "irtrtitt", + "irtrtrrr", + "irtrtrtt", + "irtrttir", + "irtt", + "irttiiir", + "irttirti", + "irttitti", + "irttittt", + "irttrrrt", + "irttrtrr", + "irttrtti", + "irtttiii", + "irtttitt", + "irtttrrr", + "irtttrrt", + "irtttrtt", + "irtttt", + "irttttit", + "irtttttr", + "irtttttt", + "it", + "it rrt", + "it t tt", + "it trtrr", + "it tt", + "it tttt", + "iti", + "itii", + "itiii", + "itiii ii", + "itiiii", + "itiiiii", + "itiiiiii", + "itiiiiit", + "itiiiit", + "itiiiiti", + "itiiiitt", + "itiiirrt", + "itiiirtr", + "itiiitii", + "itiiitit", + "itiiitti", + "itiiittt", + "itiirrrt", + "itiirtrt", + "itiit", + "itiitiii", + "itiitiit", + "itiitit", + "itiititi", + "itiittit", + "itiittti", + "itiitttt", + "itirrrrr", + "itirrrtt", + "itirrtti", + "itirtiii", + "itirtiit", + "itirttii", + "itit", + "ititiiii", + "ititiiit", + "ititiirt", + "ititiiti", + "ititiitt", + "ititirt", + "itititit", + "itititt", + "itititti", + "ititittt", + "ititrrrr", + "ititrrrt", + "ititrttt", + "ititt", + "ititti", + "itittiii", + "itittirt", + "itittit", + "itittitt", + "itittti", + "ititttit", + "ititttti", + "itittttt", + "itrrrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrtr", + "itrrrt", + "itrrrt t", + "itrrrtii", + "itrrrtrr", + "itrrrtrt", + "itrrrttt", + "itrrt", + "itrrti", + "itrrtitr", + "itrrtrrt", + "itrrtrtt", + "itrrtttr", + "itrrtttt", + "itrt", + "itrt rrr", + "itrtiirt", + "itrtirrt", + "itrtrrrr", + "itrtrrrt", + "itrtrrt", + "itrtrtrt", + "itrtrttr", + "itrtrttt", + "itrtt", + "itrttitt", + "itrttrtr", + "itrtttt", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itt tttt", + "itti", + "ittii", + "ittiii", + "ittiiiii", + "ittiiiit", + "ittiiit", + "ittiiiti", + "ittiiitr", + "ittiiitt", + "ittiitii", + "ittiittt", + "ittirrrr", + "ittirt", + "ittirttr", + "ittit", + "ittitiii", + "ittititi", + "ittititr", + "ittititt", + "ittitrrr", + "ittitrtt", + "ittittit", + "ittittt", + "ittittti", + "ittitttr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrt", + "ittrrtrr", + "ittrrttt", + "ittrt", + "ittrtrrr", + "ittrtrtr", + "ittrtrtt", + "ittrttti", + "ittrtttr", + "ittrtttt", + "ittt", + "ittti", + "itttiii", + "itttiiii", + "itttiiir", + "itttiiit", + "itttiiti", + "itttiitt", + "itttirrr", + "itttirt", + "itttitii", + "itttitit", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrrt", + "itttrrtr", + "itttrrtt", + "itttrt", + "itttrti", + "itttrttt", + "itttt", + "itttt tt", + "itttti", + "ittttiii", + "ittttiir", + "ittttiit", + "ittttitt", + "ittttrrr", + "ittttrtr", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt rr", + "rrrrt rt", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtr", + "rrrrtrr", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttr", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt t", + "rrrt r", + "rrrt rr", + "rrrt t", + "rrrt tr", + "rrrt tt", + "rrrt rrr", + "rrrt rrt", + "rrrt t", + "rrrt tii", + "rrrt tt", + "rrrti", + "rrrtii", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtt", + "rrrtit", + "rrrtiti", + "rrrtitii", + "rrrtitir", + "rrrtitit", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittt", + "rrrtr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrt t", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtr", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt rt", + "rrrtti", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttiti", + "rrrttitr", + "rrrttitt", + "rrrttrr", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt r", + "rrt rrr", + "rrt rrt", + "rrt t r", + "rrt trt", + "rrt tt", + "rrt ttt", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rtrr", + "rrt rttr", + "rrt rttt", + "rrt t", + "rrt trrr", + "rrt trrt", + "rrt trtr", + "rrt tt", + "rrt tti", + "rrt ttrr", + "rrt ttt", + "rrt tttt", + "rrti", + "rrtii", + "rrtiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiirr", + "rrtiiirt", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiirtt", + "rrtiit", + "rrtiitii", + "rrtiitit", + "rrtiitrr", + "rrtiittr", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrtr", + "rrtirrtt", + "rrtirt", + "rrtirti", + "rrtirtii", + "rrtirtir", + "rrtirtrt", + "rrtirttr", + "rrtit", + "rrtitiii", + "rrtitiit", + "rrtitirt", + "rrtititt", + "rrtitrrr", + "rrtitrrt", + "rrtitrti", + "rrtitrtt", + "rrtitt", + "rrtittii", + "rrtittir", + "rrtittit", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtitttt", + "rrtr", + "rrtrrrr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrti", + "rrtrrtii", + "rrtrrtir", + "rrtrrtit", + "rrtrrtr", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt rr", + "rrtrt tr", + "rrtrtii", + "rrtrtiii", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtit", + "rrtrtiti", + "rrtrtitt", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtti", + "rrtrttii", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt rrr", + "rrtt rrt", + "rrtt trr", + "rrtt trt", + "rrtt ttr", + "rrtt ttt", + "rrtti", + "rrttii", + "rrttii i", + "rrttiiii", + "rrttiiir", + "rrttiiit", + "rrttiirr", + "rrttiirt", + "rrttiitr", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirtr", + "rrttit", + "rrttiti", + "rrttitii", + "rrttitir", + "rrttitit", + "rrttitrr", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittr", + "rrttittt", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt rr", + "rrttti", + "rrtttiii", + "rrtttiir", + "rrtttirr", + "rrtttirt", + "rrtttit", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrti", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt i", + "rt r", + "rt t", + "rt rt", + "rt it", + "rt rrrr", + "rt rrt", + "rt rrti", + "rt rt", + "rt rtti", + "rt rttt", + "rt t", + "rt trt", + "rt trtt", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrrtr", + "rt rrt", + "rt rrtrr", + "rt rrttr", + "rt rti", + "rt rtrti", + "rt rtrtr", + "rt rtt", + "rt rttrt", + "rt t", + "rt t rrt", + "rt tiiii", + "rt trrrr", + "rt trrrt", + "rt trrtr", + "rt trrtt", + "rt trt", + "rt trtrt", + "rt trttr", + "rt tt t", + "rt ttttt", + "rti", + "rti tit", + "rti irrr", + "rtii", + "rtiii", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiir", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiit", + "rtiiiitr", + "rtiiiitt", + "rtiiirrr", + "rtiiirrt", + "rtiiirt", + "rtiiirtr", + "rtiiit", + "rtiiitii", + "rtiiitrr", + "rtiiitt", + "rtiiitti", + "rtiirrrr", + "rtiirrrt", + "rtiirrti", + "rtiirrtt", + "rtiit", + "rtiiti", + "rtiitiii", + "rtiitiit", + "rtiitrrr", + "rtiitrti", + "rtiitrtr", + "rtiitt", + "rtiitti", + "rtiittii", + "rtiittrr", + "rtiittt", + "rtiitttr", + "rtirrrrr", + "rtirrrt", + "rtirrrti", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtii", + "rtirrtir", + "rtirrtrr", + "rtirrtrt", + "rtirrtt", + "rtirrtti", + "rtirrttt", + "rtirt", + "rtirtiit", + "rtirtit", + "rtirtiti", + "rtirtitt", + "rtirtrrr", + "rtirtrt", + "rtirtrtt", + "rtirtt", + "rtirttii", + "rtirttrr", + "rtirttrt", + "rtirtttt", + "rtit", + "rtiti", + "rtitii", + "rtitirrr", + "rtitit", + "rtititii", + "rtititt", + "rtitittr", + "rtitittt", + "rtitrrrr", + "rtitrrrt", + "rtitrrt", + "rtitrrtt", + "rtitrtrt", + "rtitt", + "rtittit", + "rtittiti", + "rtittitt", + "rtittrrr", + "rtittrrt", + "rtittt", + "rtitttii", + "rtitttit", + "rtitttt", + "rtitttti", + "rtittttt", + "rtrrrrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt t", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt rr", + "rtrrti", + "rtrrtiii", + "rtrrtiit", + "rtrrtirr", + "rtrrtiti", + "rtrrtitr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt r", + "rtrt rrr", + "rtrt rti", + "rtrti", + "rtrtiiii", + "rtrtiiit", + "rtrtiirr", + "rtrtiitt", + "rtrtirrr", + "rtrtirtr", + "rtrtitii", + "rtrtitir", + "rtrtitti", + "rtrtittt", + "rtrtrrr", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrtii", + "rtrtrtir", + "rtrtrtr", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrttii", + "rtrttiii", + "rtrttiir", + "rtrttirr", + "rtrttirt", + "rtrttiti", + "rtrttitr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrtttii", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt rrr", + "rtt ttt", + "rtt rrrr", + "rtt rrrt", + "rtt rrtt", + "rtt rtrr", + "rtt rtrt", + "rtt t", + "rtt trtr", + "rtt tttt", + "rtti", + "rtti iii", + "rttii", + "rttiiiii", + "rttiiiit", + "rttiiirt", + "rttiiiti", + "rttiiitr", + "rttiiitt", + "rttiirrr", + "rttiirrt", + "rttiirt", + "rttiirtt", + "rttiit", + "rttiitii", + "rttiittt", + "rttirrrr", + "rttirrrt", + "rttirrtt", + "rttirt", + "rttirtir", + "rttirtrr", + "rttirtrt", + "rttirtt", + "rttirtti", + "rttirttr", + "rttit", + "rttitiii", + "rttitit", + "rttititi", + "rttitrrr", + "rttitrt", + "rttitrti", + "rttitrtr", + "rttitrtt", + "rttitt", + "rttitti", + "rttittii", + "rttittit", + "rttittti", + "rttitttt", + "rttrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrtir", + "rttrrtr", + "rttrrtrr", + "rttrrtrt", + "rttrrtt", + "rttrrtti", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt rt", + "rttrt tr", + "rttrtiit", + "rttrtirr", + "rttrtitt", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrti", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrtti", + "rttrttir", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt tt", + "rttt rt", + "rttti", + "rtttii t", + "rtttiiii", + "rtttiiit", + "rtttiirt", + "rtttiiti", + "rtttiitr", + "rtttiitt", + "rtttirrr", + "rtttirt", + "rtttirti", + "rtttirtt", + "rtttitii", + "rtttitit", + "rtttitrr", + "rtttitt", + "rtttitti", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrtti", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt ti", + "rtttt tr", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiir", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt i", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t r", + "t i", + "t r", + "t rr", + "t rt", + "t t", + "t tr", + "t tt", + "t trr", + "t rrrr", + "t rt", + "t t", + "t t t", + "t tt", + "t tttt", + "t rrrr", + "t rrrrr", + "t rrrt", + "t rrtr", + "t rrtt", + "t rrttt", + "t rt", + "t rti", + "t rtttt", + "t t", + "t ti", + "t tiii", + "t trrr", + "t trrrr", + "t trrt", + "t trtr", + "t trtrr", + "t tt", + "t ttit", + "t ttrrt", + "t ttt", + "t tttrt", + "t ttttr", + "t ttttt", + "t ii", + "t iii", + "t iiiii", + "t iiiiii", + "t iiirr", + "t iiittt", + "t irrrrr", + "t irrtt", + "t rr", + "t rrr", + "t rrrrr", + "t rrrrrr", + "t rrrrrt", + "t rrrrt", + "t rrrrtr", + "t rrrrtt", + "t rrrt", + "t rrrtir", + "t rrrtt", + "t rrrttr", + "t rrrttt", + "t rrt", + "t rrtiii", + "t rrtiit", + "t rrtrrr", + "t rrtrrt", + "t rrtrtr", + "t rrtt", + "t rrttrt", + "t rrtttt", + "t rt", + "t rt rt", + "t rtiiii", + "t rtitii", + "t rtrrrr", + "t rtrrrt", + "t rtrrtt", + "t rtrtrr", + "t rtrttt", + "t rtt", + "t rttttr", + "t rttttt", + "t t", + "t t tt", + "t t rrt", + "t t t tt", + "t t tt", + "t tii", + "t tiiiit", + "t trrrrr", + "t trrrrt", + "t trrt t", + "t trrtrr", + "t trrtrt", + "t trrtti", + "t trtrrr", + "t trtrt", + "t trtrtr", + "t trttt", + "t trtttt", + "t tt", + "t tt r", + "t tti", + "t ttitrr", + "t ttrrrr", + "t ttrrrt", + "t ttrrtr", + "t ttrt", + "t ttrtrr", + "t ttt", + "t tttrrr", + "t tttrtt", + "t tttt", + "t ttttti", + "t tttttt", + "ti", + "ti i", + "ti iiit", + "ti tti", + "ti i", + "ti rrrrt", + "ti rtt", + "tii", + "tii tti", + "tii trtt", + "tiii", + "tiiii", + "tiiiii", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirti", + "tiiiirtt", + "tiiiit", + "tiiiiti", + "tiiiitii", + "tiiiitrr", + "tiiiitrt", + "tiiiitti", + "tiiiittr", + "tiiiittt", + "tiiirrrr", + "tiiirrrt", + "tiiirrt", + "tiiirrtr", + "tiiirrtt", + "tiiirtir", + "tiiirtit", + "tiiirtrt", + "tiiirtti", + "tiiit", + "tiiiti", + "tiiitiii", + "tiiitiit", + "tiiitirr", + "tiiitirt", + "tiiitit", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitt", + "tiiitti", + "tiiittii", + "tiiittir", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttt", + "tiirrrr", + "tiirrrrr", + "tiirrrrt", + "tiirrrti", + "tiirrrtt", + "tiirrti", + "tiirrtii", + "tiirrtir", + "tiirrtrr", + "tiirrtrt", + "tiirrttt", + "tiirt", + "tiirti", + "tiirtrrt", + "tiirttrr", + "tiit", + "tiit tt", + "tiiti", + "tiitii", + "tiitiii", + "tiitiiii", + "tiitiiir", + "tiitiirr", + "tiitiiti", + "tiitiitr", + "tiitiitt", + "tiitirtr", + "tiitirtt", + "tiititir", + "tiititit", + "tiititrt", + "tiititt", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrt", + "tiitrti", + "tiitrtrt", + "tiitt", + "tiittiii", + "tiittiir", + "tiittiit", + "tiittitt", + "tiittrrr", + "tiittrrt", + "tiittrt", + "tiittrtr", + "tiittrtt", + "tiitttit", + "tiitttrr", + "tiitttt", + "tiitttti", + "tiittttr", + "tiittttt", + "tirrrrr", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtir", + "tirrrtit", + "tirrrtrr", + "tirrrtt", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrtirr", + "tirrtiti", + "tirrtitt", + "tirrtrrr", + "tirrtrrt", + "tirrtrtr", + "tirrtrtt", + "tirrtt", + "tirrttir", + "tirrtttr", + "tirrtttt", + "tirt", + "tirtiiii", + "tirtiiir", + "tirtiirr", + "tirtitii", + "tirtrrrr", + "tirtrrrt", + "tirtrrt", + "tirtrrtt", + "tirtrttt", + "tirtt", + "tirttiir", + "tirttirr", + "tirttitr", + "tirttrrt", + "tirttrtt", + "tirttt", + "tirtttit", + "tirttttt", + "tit", + "tit iiit", + "tit itir", + "tit rttt", + "titi", + "titii", + "titiiiii", + "titiiiit", + "titiiirr", + "titiiiti", + "titiiitr", + "titiiitt", + "titiitii", + "titiittt", + "titirrrr", + "titirtrt", + "titit", + "tititi", + "tititii", + "titititt", + "tititrrt", + "tititrtt", + "tititt", + "titittii", + "titittit", + "titittrt", + "titittt", + "titittti", + "tititttr", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrt", + "titrrtii", + "titrrttr", + "titrrttt", + "titrt", + "titrti", + "titrtit", + "titrtrrr", + "titrtrtr", + "titrtrtt", + "titrtt", + "titrttrr", + "titrttrt", + "titrtttr", + "titrtttt", + "titt", + "titt ttt", + "titti", + "tittiiii", + "tittiiir", + "tittiiit", + "tittiirr", + "tittiiti", + "tittiitr", + "tittiitt", + "tittirtr", + "tittitit", + "tittitti", + "tittittt", + "tittrrrr", + "tittrrti", + "tittrrtr", + "tittrtrt", + "tittrttr", + "tittrttt", + "tittt", + "tittti", + "titttiii", + "titttiit", + "titttit", + "titttiti", + "titttitt", + "titttrrr", + "titttrrt", + "titttrt", + "titttrtt", + "titttt", + "titttt t", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trr", + "trrr", + "trrrr", + "trrrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt t", + "trrrrtii", + "trrrrtir", + "trrrrtit", + "trrrrtr", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt rr", + "trrrti", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirr", + "trrrtirt", + "trrrtit", + "trrrtitr", + "trrrtitt", + "trrrtrr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrti", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtti", + "trrrttii", + "trrrttir", + "trrrttit", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrttti", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt r", + "trrt tr", + "trrt rrt", + "trrt t", + "trrt tt", + "trrt ttt", + "trrti", + "trrtiii", + "trrtiiii", + "trrtiirr", + "trrtiitt", + "trrtirrt", + "trrtirt", + "trrtirtt", + "trrtitit", + "trrtitrr", + "trrtittt", + "trrtr", + "trrtrrr", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt r", + "trrtrtii", + "trrtrtir", + "trrtrtit", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrttiii", + "trrttiit", + "trrttirr", + "trrttiti", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrti", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttt r", + "trrttt t", + "trrtttii", + "trrtttir", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt trr", + "trt rrrr", + "trt rttt", + "trt tttt", + "trti", + "trtii", + "trtii rt", + "trtiii", + "trtiiii", + "trtiiiii", + "trtiirrr", + "trtiirrt", + "trtiitii", + "trtiitti", + "trtirrrr", + "trtirrrt", + "trtirrtr", + "trtirt", + "trtirtii", + "trtirtir", + "trtirtrr", + "trtirtt", + "trtirttt", + "trtit", + "trtitrrr", + "trtitrtr", + "trtitrtt", + "trtitt", + "trtittii", + "trtitttr", + "trtr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt t", + "trtrrtr", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrt rr", + "trtrti", + "trtrtii", + "trtrtirt", + "trtrtiti", + "trtrtitt", + "trtrtr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrtti", + "trtrttii", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt rr", + "trtt t", + "trtti", + "trttii", + "trttiiii", + "trttiirt", + "trttirrr", + "trttirrt", + "trttirtr", + "trttit", + "trttitrt", + "trttitti", + "trttittt", + "trttr", + "trttrrrr", + "trttrrrt", + "trttrrt", + "trttrrti", + "trttrrtr", + "trttrrtt", + "trttrt", + "trttrtrr", + "trttrtrt", + "trttrtti", + "trttrttr", + "trttrttt", + "trttt", + "trttti", + "trtttiii", + "trtttiit", + "trtttirt", + "trtttitr", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttt i", + "trtttt t", + "trtttti", + "trttttii", + "trttttir", + "trttttit", + "trttttr", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt i", + "tt t", + "tt ii", + "tt rr", + "tt rt", + "tt tt", + "tt trt", + "tt iii", + "tt t tr", + "tt trrr", + "tt i", + "tt rrrrr", + "tt rrrrt", + "tt rrrt", + "tt rrttt", + "tt rtrrr", + "tt rtrtt", + "tt t", + "tt t t t", + "tt tiiii", + "tt tittt", + "tt trrtr", + "tt trrtt", + "tt trt", + "tt ttrrr", + "tt tttii", + "tt tttt", + "tt tttti", + "tt ttttt", + "tti", + "tti iii", + "tti itt", + "tti iitt", + "tti rrrt", + "tti trtr", + "tti ttt", + "ttii", + "ttii iii", + "ttiii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiit", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiirtt", + "ttiiit", + "ttiiitii", + "ttiiitit", + "ttiiitrr", + "ttiiitrt", + "ttiiitt", + "ttiiitti", + "ttiiittr", + "ttiiittt", + "ttiirrrr", + "ttiirrrt", + "ttiirrti", + "ttiirrtr", + "ttiirttt", + "ttiit", + "ttiitiii", + "ttiitiir", + "ttiitiit", + "ttiititi", + "ttiititr", + "ttiititt", + "ttiitrrr", + "ttiitrtr", + "ttiitrtt", + "ttiitt", + "ttiittii", + "ttiittir", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrt", + "ttirrtii", + "ttirrtrr", + "ttirrttr", + "ttirrttt", + "ttirtiii", + "ttirtirt", + "ttirtrrr", + "ttirtrrt", + "ttirtrti", + "ttirtrtr", + "ttirtt", + "ttirttit", + "ttirttrt", + "ttirtttr", + "ttirtttt", + "ttit", + "ttiti", + "ttitiiii", + "ttitiiit", + "ttitiirr", + "ttitiirt", + "ttitiit", + "ttitiiti", + "ttitiitt", + "ttitit", + "ttititii", + "ttititrt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrr", + "ttitrrrr", + "ttitrrrt", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrtt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttitti", + "ttittiii", + "ttittiit", + "ttittirt", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttir", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrt", + "ttrrrtii", + "ttrrrtir", + "ttrrrtr", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt rr", + "ttrrt rt", + "ttrrt tt", + "ttrrti", + "ttrrtiii", + "ttrrtiit", + "ttrrtirr", + "ttrrtit", + "ttrrtiti", + "ttrrtitt", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrtti", + "ttrrttir", + "ttrrttit", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt rrt", + "ttrti", + "ttrtiiit", + "ttrtirtr", + "ttrtit", + "ttrtitit", + "ttrtitrr", + "ttrtitrt", + "ttrtittt", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrti", + "ttrtrtii", + "ttrtrtir", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtt t", + "ttrtt rt", + "ttrtt tt", + "ttrtti", + "ttrttiii", + "ttrttiit", + "ttrttitr", + "ttrttitt", + "ttrttr", + "ttrttrrr", + "ttrttrrt", + "ttrttrti", + "ttrttrtr", + "ttrttrtt", + "ttrttti", + "ttrtttii", + "ttrtttir", + "ttrtttit", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt rt", + "ttt rt", + "ttt rtt", + "ttt trr", + "ttt tt", + "ttt ttt", + "ttt iiit", + "ttt ittt", + "ttt rttr", + "ttt t", + "ttt trrr", + "ttt tt r", + "ttt ttrr", + "ttt ttt", + "ttt ttti", + "ttt tttt", + "ttti", + "tttii", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiit", + "tttiiirr", + "tttiiiti", + "tttiiitr", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiirt", + "tttiirtr", + "tttiirtt", + "tttiit", + "tttiitii", + "tttiitir", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrrt", + "tttirrti", + "tttirrtr", + "tttirrtt", + "tttirt r", + "tttirtit", + "tttirtti", + "tttirttt", + "tttit", + "tttit tt", + "tttiti", + "tttitiii", + "tttitiit", + "tttitirr", + "tttititi", + "tttititr", + "tttititt", + "tttitrrr", + "tttitrrt", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitt t", + "tttittii", + "tttittir", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrti", + "tttrrtii", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt rt", + "tttrt tt", + "tttrti", + "tttrtiii", + "tttrtiit", + "tttrtirr", + "tttrtirt", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrti", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrttii", + "tttrttit", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt i", + "tttt r", + "tttt t", + "tttt tr", + "tttt tt", + "tttt i", + "tttt rrt", + "tttt tir", + "tttt tt", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti i", + "tttti t", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirtt", + "ttttit", + "ttttit r", + "ttttit t", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttr", + "ttttrr", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrti", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt t", + "ttttt i", + "ttttt ii", + "ttttt rr", + "ttttt t", + "ttttt tr", + "ttttt tt", + "ttttti", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ], + "eads08_rvlr28": [ + "-1", + "-2", + "-6", + "i", + "i rrr", + "i iiitt", + "i rrrrr", + "i tt", + "i ttrtt", + "i iiii", + "i irrrrr", + "i trrrr", + "ii", + "ii ttt", + "ii i", + "iii", + "iii ii", + "iii iiii", + "iii trt", + "iiii", + "iiii i", + "iiii i", + "iiii iii", + "iiiii", + "iiiii ii", + "iiiiii", + "iiiiii r", + "iiiiiii", + "iiiiiiii", + "iiiiiiir", + "iiiiiiit", + "iiiiiirr", + "iiiiiirt", + "iiiiiit", + "iiiiiiti", + "iiiiiitr", + "iiiiiitt", + "iiiiir", + "iiiiirrr", + "iiiiirrt", + "iiiiirt", + "iiiiirti", + "iiiiirtr", + "iiiiirtt", + "iiiiit", + "iiiiit r", + "iiiiiti", + "iiiiitii", + "iiiiitit", + "iiiiitrr", + "iiiiitrt", + "iiiiitt", + "iiiiitti", + "iiiiittr", + "iiiiittt", + "iiiirrr", + "iiiirrrr", + "iiiirrrt", + "iiiirrt", + "iiiirrtr", + "iiiirt", + "iiiirti", + "iiiirtii", + "iiiirtrr", + "iiiirtrt", + "iiiirtti", + "iiiirttr", + "iiiirttt", + "iiiit", + "iiiiti", + "iiiitii", + "iiiitiii", + "iiiitiit", + "iiiitirr", + "iiiitirt", + "iiiititi", + "iiiititr", + "iiiititt", + "iiiitrrr", + "iiiitrti", + "iiiitrtr", + "iiiitrtt", + "iiiitt", + "iiiittii", + "iiiittit", + "iiiittrr", + "iiiittrt", + "iiiittt", + "iiiittti", + "iiiitttr", + "iiiitttt", + "iiirrrrr", + "iiirrrrt", + "iiirrrt", + "iiirrrti", + "iiirrrtr", + "iiirrrtt", + "iiirrt", + "iiirrtii", + "iiirrtrr", + "iiirrtrt", + "iiirrtt", + "iiirrttr", + "iiirrttt", + "iiirt", + "iiirtii", + "iiirtiir", + "iiirtrrr", + "iiirtrrt", + "iiirtrti", + "iiirtrtt", + "iiirtt", + "iiirttti", + "iiirtttr", + "iiirtttt", + "iiit", + "iiit iii", + "iiiti", + "iiitii", + "iiitiiii", + "iiitiiir", + "iiitiiit", + "iiitiirr", + "iiitiit", + "iiitiiti", + "iiitiitr", + "iiitiitt", + "iiitirrr", + "iiitit", + "iiititi", + "iiititii", + "iiititit", + "iiititrr", + "iiititrt", + "iiititt", + "iiititti", + "iiitittt", + "iiitrrrr", + "iiitrrrt", + "iiitrrt", + "iiitrrtr", + "iiitrrtt", + "iiitrt", + "iiitrtii", + "iiitrttt", + "iiitt", + "iiitti", + "iiittiii", + "iiittiit", + "iiittirr", + "iiittiti", + "iiittitt", + "iiittrrr", + "iiittrti", + "iiittrtr", + "iiittrtt", + "iiittt", + "iiitttii", + "iiitttit", + "iiitttrr", + "iiitttrt", + "iiitttt", + "iiitttti", + "iiittttr", + "iiittttt", + "iirrrrrr", + "iirrrrrt", + "iirrrrt", + "iirrrrtr", + "iirrrrtt", + "iirrrt", + "iirrrtii", + "iirrrtir", + "iirrrtrr", + "iirrrtrt", + "iirrrttt", + "iirrt", + "iirrti", + "iirrtii", + "iirrtiii", + "iirrtiir", + "iirrtrrr", + "iirrtrrt", + "iirrtt", + "iirrtt t", + "iirrttii", + "iirrtttt", + "iirt", + "iirti", + "iirtiiii", + "iirtiiir", + "iirtiirr", + "iirtiitt", + "iirtrrrr", + "iirtrrti", + "iirtt", + "iirttirt", + "iirtttrr", + "iirtttt", + "iirtttti", + "iit", + "iit t", + "iiti", + "iiti t", + "iitii", + "iitii rr", + "iitiii", + "iitiiii", + "iitiiiii", + "iitiiiit", + "iitiiirr", + "iitiiirt", + "iitiiit", + "iitiiiti", + "iitiiitr", + "iitiiitt", + "iitiirrr", + "iitiirtt", + "iitiit", + "iitiitii", + "iitiitit", + "iitiitrr", + "iitiitt", + "iitiitti", + "iitiittr", + "iitiittt", + "iitirrrr", + "iitirtii", + "iitirtti", + "iitit", + "iitit rr", + "iititiii", + "iititiit", + "iitititi", + "iitititt", + "iititrrr", + "iititrtt", + "iitittii", + "iitittrr", + "iitittt", + "iititttr", + "iititttt", + "iitrrrrr", + "iitrrrrt", + "iitrrrti", + "iitrrrtr", + "iitrrrtt", + "iitrrtii", + "iitrrtrr", + "iitrrttt", + "iitrt", + "iitrtiii", + "iitrtrtt", + "iitrtt", + "iitrtti", + "iitrttrt", + "iitrtttt", + "iitt", + "iitt trt", + "iitti", + "iittii", + "iittiii", + "iittiiii", + "iittiiit", + "iittiirt", + "iittiit", + "iittiiti", + "iittiitt", + "iittit", + "iittitit", + "iittitti", + "iittittt", + "iittrrrr", + "iittrrrt", + "iittrrt", + "iittrrti", + "iittrrtr", + "iittrt", + "iittrtrr", + "iittrtrt", + "iittrtti", + "iittrttt", + "iittt", + "iittt tr", + "iittti", + "iitttii", + "iitttiii", + "iitttiit", + "iitttiti", + "iitttitt", + "iitttrrt", + "iitttrtr", + "iitttrtt", + "iitttt", + "iitttti", + "iittttii", + "iittttrr", + "iittttrt", + "iittttt", + "iittttti", + "iitttttr", + "iitttttt", + "ir", + "irr", + "irrr", + "irrrrrrr", + "irrrrrrt", + "irrrrrti", + "irrrrrtr", + "irrrrrtt", + "irrrrt", + "irrrrtii", + "irrrrtrr", + "irrrrtt", + "irrrrttt", + "irrrt", + "irrrtiti", + "irrrtrrr", + "irrrtrrt", + "irrrtrti", + "irrrttii", + "irrrttrt", + "irrrtttr", + "irrt", + "irrt rrr", + "irrt rti", + "irrt tti", + "irrti", + "irrtiiii", + "irrtit", + "irrtitit", + "irrtrrrr", + "irrtrrrt", + "irrtrrt", + "irrtrrtt", + "irrtrtrr", + "irrtt", + "irrttirt", + "irrttiti", + "irrttt", + "irrtttrr", + "irrtttti", + "irrttttt", + "irt", + "irt iiii", + "irt rrrr", + "irti", + "irtiiiii", + "irtiiitt", + "irtirrrr", + "irtirrrt", + "irtirrti", + "irtirtrt", + "irtit", + "irtittit", + "irtrrrrr", + "irtrrrt", + "irtrrrtr", + "irtrrrtt", + "irtrrtrt", + "irtrrtti", + "irtrrttt", + "irtrtrrr", + "irtrtrtr", + "irtrtrtt", + "irtrttrr", + "irtt", + "irttiii", + "irttiiii", + "irttiit", + "irttiitt", + "irttirrr", + "irttirti", + "irttrrrr", + "irttrrti", + "irttrt", + "irttrtt", + "irttt", + "irtttiir", + "irtttit", + "irtttiti", + "irtttitt", + "irtttrrt", + "irtttt", + "irttttii", + "irttttrt", + "irtttttr", + "irtttttt", + "it", + "it ii", + "it rtrt", + "it ttii", + "it iirtt", + "it iitti", + "it tit", + "iti", + "itii", + "itiii", + "itiiiiii", + "itiiiiir", + "itiiiiit", + "itiiiirr", + "itiiiiti", + "itiiiitt", + "itiiirrr", + "itiiirrt", + "itiiirti", + "itiiitii", + "itiiitit", + "itiiitrr", + "itiiitrt", + "itiiitti", + "itiiittt", + "itiirrrr", + "itiirttt", + "itiit", + "itiitiii", + "itiitiit", + "itiitirr", + "itiititt", + "itiitt", + "itiittit", + "itiittti", + "itiitttt", + "itirrrrr", + "itirrrrt", + "itirrrtt", + "itirrtit", + "itirrttt", + "itirtiti", + "itirtrrt", + "itirtt", + "itit", + "ititi", + "ititii", + "ititiiii", + "ititiiit", + "ititiirr", + "ititiiti", + "ititiitt", + "itititii", + "itititit", + "itititrr", + "itititti", + "ititittt", + "ititrrrr", + "ititrrrt", + "ititt", + "ititti", + "itittiii", + "itittiit", + "itittrrr", + "itittt", + "ititttii", + "ititttit", + "ititttt", + "itittttr", + "itittttt", + "itr", + "itrrrrr", + "itrrrrrr", + "itrrrrrt", + "itrrrrt", + "itrrrrti", + "itrrrrtt", + "itrrrtit", + "itrrrtrr", + "itrrt", + "itrrtiii", + "itrrtrrr", + "itrrtrrt", + "itrrtrtt", + "itrrttrr", + "itrrttt", + "itrrtttt", + "itrt", + "itrti", + "itrtii", + "itrtiiii", + "itrtiiit", + "itrtiit", + "itrtirrt", + "itrtrrrt", + "itrtrrt", + "itrtrrtr", + "itrtrrtt", + "itrtrtrt", + "itrtrtt", + "itrttirt", + "itrttitt", + "itrttrti", + "itrtttti", + "itrttttr", + "itrttttt", + "itt", + "itti", + "ittii", + "ittiii", + "ittiiii", + "ittiiiii", + "ittiiiit", + "ittiiiti", + "ittiirrt", + "ittiitii", + "ittiitit", + "ittiitrr", + "ittiittr", + "ittiittt", + "ittirrrr", + "ittirrti", + "ittirrtt", + "ittirtir", + "ittirtit", + "ittit", + "ittiti", + "ittitii", + "ittitiii", + "ittitiit", + "ittittii", + "ittittrt", + "ittittt", + "ittittti", + "ittitttr", + "ittitttt", + "ittrrrrr", + "ittrrrrt", + "ittrrrtr", + "ittrrrtt", + "ittrrttt", + "ittrt", + "ittrtiii", + "ittrtrrr", + "ittrtrtt", + "ittrtt", + "ittrttir", + "ittrttit", + "ittrtttt", + "ittt", + "ittt rt", + "ittti", + "itttiii", + "itttiiii", + "itttiiit", + "itttiiti", + "itttiitt", + "itttirrr", + "itttirt", + "itttit t", + "itttitii", + "itttitit", + "itttitt", + "itttitti", + "itttittr", + "itttittt", + "itttrrrr", + "itttrrtr", + "itttrtrt", + "itttrttr", + "itttt", + "itttti", + "ittttiii", + "ittttiit", + "ittttit", + "ittttiti", + "ittttitt", + "ittttrrt", + "ittttrt", + "ittttrti", + "ittttrtt", + "ittttt", + "ittttti", + "itttttii", + "itttttir", + "itttttit", + "itttttrr", + "itttttrt", + "itttttt", + "itttttti", + "ittttttr", + "ittttttt", + "r", + "rrr", + "rrrr", + "rrrrr", + "rrrrrr", + "rrrrrrr", + "rrrrrrrr", + "rrrrrrrt", + "rrrrrrt", + "rrrrrrti", + "rrrrrrtr", + "rrrrrrtt", + "rrrrrt", + "rrrrrt r", + "rrrrrt t", + "rrrrrti", + "rrrrrtii", + "rrrrrtir", + "rrrrrtit", + "rrrrrtr", + "rrrrrtrr", + "rrrrrtrt", + "rrrrrtt", + "rrrrrtti", + "rrrrrttr", + "rrrrrttt", + "rrrrt", + "rrrrt rr", + "rrrrt t", + "rrrrt tr", + "rrrrt tt", + "rrrrti", + "rrrrtii", + "rrrrtiii", + "rrrrtiir", + "rrrrtiit", + "rrrrtirr", + "rrrrtirt", + "rrrrtit", + "rrrrtiti", + "rrrrtitr", + "rrrrtitt", + "rrrrtrrr", + "rrrrtrrt", + "rrrrtrt", + "rrrrtrti", + "rrrrtrtr", + "rrrrtrtt", + "rrrrtt", + "rrrrtt r", + "rrrrtt t", + "rrrrtti", + "rrrrttii", + "rrrrttir", + "rrrrttit", + "rrrrttrr", + "rrrrttrt", + "rrrrttt", + "rrrrttti", + "rrrrtttr", + "rrrrtttt", + "rrrt", + "rrrt r", + "rrrt rr", + "rrrt tr", + "rrrt tt", + "rrrt rrr", + "rrrt rrt", + "rrrt rtr", + "rrrt tii", + "rrrt tit", + "rrrt trr", + "rrrt trt", + "rrrt tt", + "rrrt ttr", + "rrrt ttt", + "rrrti", + "rrrti t", + "rrrtii", + "rrrtii i", + "rrrtiii", + "rrrtiiii", + "rrrtiiir", + "rrrtiiit", + "rrrtiirr", + "rrrtiirt", + "rrrtiit", + "rrrtiiti", + "rrrtiitr", + "rrrtiitt", + "rrrtirrr", + "rrrtirrt", + "rrrtirt", + "rrrtirti", + "rrrtirtt", + "rrrtit", + "rrrtit r", + "rrrtitii", + "rrrtitir", + "rrrtitrr", + "rrrtitrt", + "rrrtitt", + "rrrtitti", + "rrrtittr", + "rrrtittt", + "rrrtrr", + "rrrtrrr", + "rrrtrrrr", + "rrrtrrrt", + "rrrtrrt", + "rrrtrrti", + "rrrtrrtr", + "rrrtrrtt", + "rrrtrt", + "rrrtrti", + "rrrtrtii", + "rrrtrtir", + "rrrtrtit", + "rrrtrtrr", + "rrrtrtrt", + "rrrtrtt", + "rrrtrtti", + "rrrtrttr", + "rrrtrttt", + "rrrtt", + "rrrtt t", + "rrrtt rr", + "rrrtti", + "rrrtti t", + "rrrttii", + "rrrttiii", + "rrrttiir", + "rrrttiit", + "rrrttirr", + "rrrttirt", + "rrrttit", + "rrrttitr", + "rrrttitt", + "rrrttrrr", + "rrrttrrt", + "rrrttrt", + "rrrttrti", + "rrrttrtr", + "rrrttrtt", + "rrrttt", + "rrrttt t", + "rrrttti", + "rrrtttii", + "rrrtttir", + "rrrtttit", + "rrrtttrr", + "rrrtttrt", + "rrrtttt", + "rrrtttti", + "rrrttttr", + "rrrttttt", + "rrt", + "rrt i", + "rrt rrr", + "rrt rrt", + "rrt trr", + "rrt trt", + "rrt rrrr", + "rrt rrrt", + "rrt rrt", + "rrt rrtr", + "rrt rrtt", + "rrt rt t", + "rrt rtit", + "rrt rtr", + "rrt rtrt", + "rrt rtti", + "rrt rttt", + "rrt t", + "rrt tirr", + "rrt titt", + "rrt trrr", + "rrt trt", + "rrt ttrr", + "rrt tttt", + "rrti", + "rrti rrt", + "rrtii", + "rrtiii", + "rrtiiii", + "rrtiiiii", + "rrtiiiir", + "rrtiiiit", + "rrtiiirr", + "rrtiiit", + "rrtiiiti", + "rrtiiitr", + "rrtiiitt", + "rrtiirrr", + "rrtiirrt", + "rrtiitii", + "rrtiitir", + "rrtiitit", + "rrtiitrr", + "rrtiitrt", + "rrtiitti", + "rrtiittt", + "rrtirrrr", + "rrtirrrt", + "rrtirrt", + "rrtirrti", + "rrtirrtr", + "rrtirt", + "rrtirti", + "rrtirtrt", + "rrtirtt", + "rrtirtti", + "rrtirttr", + "rrtirttt", + "rrtit", + "rrtitiii", + "rrtitirr", + "rrtititi", + "rrtititt", + "rrtitrrr", + "rrtitrt", + "rrtitrti", + "rrtitrtr", + "rrtitt", + "rrtittii", + "rrtittrr", + "rrtittrt", + "rrtittt", + "rrtitttr", + "rrtitttt", + "rrtr", + "rrtrrrrr", + "rrtrrrrt", + "rrtrrrt", + "rrtrrrti", + "rrtrrrtr", + "rrtrrrtt", + "rrtrrt", + "rrtrrt r", + "rrtrrt t", + "rrtrrtii", + "rrtrrtit", + "rrtrrtrr", + "rrtrrtrt", + "rrtrrtt", + "rrtrrtti", + "rrtrrttr", + "rrtrrttt", + "rrtrt", + "rrtrt t", + "rrtrt rr", + "rrtrt t", + "rrtrt tr", + "rrtrti", + "rrtrtiii", + "rrtrtiir", + "rrtrtiit", + "rrtrtirr", + "rrtrtirt", + "rrtrtitt", + "rrtrtrr", + "rrtrtrrr", + "rrtrtrrt", + "rrtrtrt", + "rrtrtrti", + "rrtrtrtr", + "rrtrtrtt", + "rrtrtt", + "rrtrtt i", + "rrtrtt t", + "rrtrttii", + "rrtrttir", + "rrtrttit", + "rrtrttrr", + "rrtrttrt", + "rrtrttt", + "rrtrttti", + "rrtrtttr", + "rrtrtttt", + "rrtt", + "rrtt rrr", + "rrtti", + "rrttii", + "rrttiiii", + "rrttiiir", + "rrttiirr", + "rrttiit", + "rrttiitt", + "rrttirrr", + "rrttirrt", + "rrttirt", + "rrttirtr", + "rrttirtt", + "rrttit", + "rrttit t", + "rrttitrt", + "rrttitt", + "rrttitti", + "rrttittt", + "rrttrrr", + "rrttrrrr", + "rrttrrrt", + "rrttrrt", + "rrttrrti", + "rrttrrtr", + "rrttrrtt", + "rrttrt", + "rrttrt r", + "rrttrt t", + "rrttrtir", + "rrttrtit", + "rrttrtrr", + "rrttrtrt", + "rrttrtt", + "rrttrtti", + "rrttrttr", + "rrttrttt", + "rrttt", + "rrttt rt", + "rrttt tt", + "rrttti", + "rrtttii", + "rrtttiii", + "rrtttiir", + "rrtttiit", + "rrtttirr", + "rrtttirt", + "rrtttiti", + "rrtttitr", + "rrtttitt", + "rrtttrr", + "rrtttrrr", + "rrtttrrt", + "rrtttrt", + "rrtttrtr", + "rrtttrtt", + "rrtttt", + "rrtttt t", + "rrtttti", + "rrttttii", + "rrttttir", + "rrttttit", + "rrttttrr", + "rrttttrt", + "rrttttt", + "rrttttti", + "rrtttttr", + "rrtttttt", + "rt", + "rt tt", + "rt rrrr", + "rt trrr", + "rt trrt", + "rt tttt", + "rt i", + "rt irrtr", + "rt rrrrr", + "rt rrrrt", + "rt rrrt", + "rt rrttt", + "rt rt rr", + "rt rtt", + "rt rtti", + "rt rtttr", + "rt rtttt", + "rt t", + "rt t tt", + "rt trrrt", + "rt trrt", + "rt trtii", + "rt trtrr", + "rt ttitt", + "rt tttti", + "rti", + "rti rrrt", + "rti tiii", + "rtii", + "rtiii", + "rtiii i", + "rtiii rr", + "rtiiii", + "rtiiiii", + "rtiiiiii", + "rtiiiiit", + "rtiiiirr", + "rtiiiirt", + "rtiiiiti", + "rtiiirrr", + "rtiiirrt", + "rtiiitrr", + "rtiiitrt", + "rtiiitt", + "rtiiittt", + "rtiirrrr", + "rtiirrrt", + "rtiirrt", + "rtiirtii", + "rtiirtrt", + "rtiit", + "rtiitiii", + "rtiitiit", + "rtiitrrr", + "rtiitrrt", + "rtiitrtr", + "rtiitt", + "rtiittrr", + "rtirrrrr", + "rtirrrrt", + "rtirrrt", + "rtirrrtr", + "rtirrrtt", + "rtirrt", + "rtirrtrr", + "rtirrtrt", + "rtirrttr", + "rtirrttt", + "rtirt", + "rtirtiit", + "rtirtirr", + "rtirtirt", + "rtirtit", + "rtirtitt", + "rtirtrtt", + "rtirttii", + "rtirttit", + "rtirtttt", + "rtit", + "rtiti", + "rtitiiii", + "rtitiiit", + "rtitiirr", + "rtitiitr", + "rtitiitt", + "rtitirrt", + "rtititi", + "rtititrt", + "rtitittt", + "rtitrrrr", + "rtitrrti", + "rtitrtrt", + "rtitrttt", + "rtitt", + "rtittiii", + "rtittiit", + "rtittirr", + "rtittitt", + "rtittrtt", + "rtittt", + "rtitttit", + "rtitttrr", + "rtitttt", + "rtittttt", + "rtrr", + "rtrrrrrr", + "rtrrrrrt", + "rtrrrrt", + "rtrrrrti", + "rtrrrrtr", + "rtrrrrtt", + "rtrrrt", + "rtrrrt r", + "rtrrrti", + "rtrrrtii", + "rtrrrtir", + "rtrrrtit", + "rtrrrtrr", + "rtrrrtrt", + "rtrrrtt", + "rtrrrtti", + "rtrrrttr", + "rtrrrttt", + "rtrrt", + "rtrrt r", + "rtrrt t", + "rtrrt tr", + "rtrrti", + "rtrrtiii", + "rtrrtiir", + "rtrrtiit", + "rtrrtirr", + "rtrrtirt", + "rtrrtit", + "rtrrtiti", + "rtrrtitr", + "rtrrtr", + "rtrrtrrr", + "rtrrtrrt", + "rtrrtrt", + "rtrrtrti", + "rtrrtrtr", + "rtrrtrtt", + "rtrrtt", + "rtrrtt r", + "rtrrtt t", + "rtrrtti", + "rtrrttii", + "rtrrttir", + "rtrrttit", + "rtrrttr", + "rtrrttrr", + "rtrrttrt", + "rtrrttt", + "rtrrttti", + "rtrrtttr", + "rtrrtttt", + "rtrt", + "rtrt rrr", + "rtrt rtr", + "rtrt rtt", + "rtrt trr", + "rtrti", + "rtrtiiii", + "rtrtiirr", + "rtrtiiti", + "rtrtiitr", + "rtrtirrt", + "rtrtirtr", + "rtrtitii", + "rtrtitt", + "rtrtrrrr", + "rtrtrrrt", + "rtrtrrt", + "rtrtrrti", + "rtrtrrtr", + "rtrtrrtt", + "rtrtrt", + "rtrtrt t", + "rtrtrti", + "rtrtrtir", + "rtrtrtit", + "rtrtrtrr", + "rtrtrtrt", + "rtrtrtt", + "rtrtrtti", + "rtrtrttr", + "rtrtrttt", + "rtrtt", + "rtrtt tr", + "rtrtti", + "rtrttiii", + "rtrttirr", + "rtrttitt", + "rtrttrrr", + "rtrttrrt", + "rtrttrti", + "rtrttrtr", + "rtrttrtt", + "rtrttt", + "rtrttt t", + "rtrtttir", + "rtrtttit", + "rtrtttrr", + "rtrtttrt", + "rtrtttt", + "rtrtttti", + "rtrttttr", + "rtrttttt", + "rtt", + "rtt rrt", + "rtt trr", + "rtt tt", + "rtt rrrr", + "rtt rrtt", + "rtt rtt", + "rtt rttt", + "rtt tii", + "rtt ttrt", + "rtti", + "rtti i", + "rtti it", + "rttii", + "rttiiiii", + "rttiiiir", + "rttiiiit", + "rttiiir", + "rttiiirt", + "rttiiitr", + "rttiiitt", + "rttiirtr", + "rttiirtt", + "rttiit", + "rttiiti", + "rttiitii", + "rttiitrt", + "rttiittr", + "rttiittt", + "rttirr", + "rttirrrr", + "rttirrrt", + "rttirrtr", + "rttirrtt", + "rttirt t", + "rttirtrr", + "rttirtt", + "rttirtti", + "rttit", + "rttitiii", + "rttitiit", + "rttitirr", + "rttitirt", + "rttitrrr", + "rttitrti", + "rttittii", + "rttittit", + "rttittti", + "rttitttr", + "rttitttt", + "rttrrr", + "rttrrrr", + "rttrrrrr", + "rttrrrrt", + "rttrrrt", + "rttrrrti", + "rttrrrtr", + "rttrrrtt", + "rttrrt", + "rttrrt t", + "rttrrtir", + "rttrrtrr", + "rttrrtrt", + "rttrrttr", + "rttrrttt", + "rttrt", + "rttrt tr", + "rttrtiii", + "rttrtiit", + "rttrtirr", + "rttrtirt", + "rttrtitr", + "rttrtitt", + "rttrtr", + "rttrtrrr", + "rttrtrrt", + "rttrtrt", + "rttrtrtr", + "rttrtrtt", + "rttrtt", + "rttrttii", + "rttrttir", + "rttrttit", + "rttrttrr", + "rttrttrt", + "rttrttt", + "rttrttti", + "rttrtttr", + "rttrtttt", + "rttt", + "rttt r", + "rttt t", + "rttt t t", + "rttt trr", + "rttt tt", + "rttti", + "rtttiiii", + "rtttiiit", + "rtttiit", + "rtttiitt", + "rtttirrr", + "rtttirtt", + "rtttit", + "rtttitii", + "rtttitit", + "rtttitrr", + "rtttittt", + "rtttrrrr", + "rtttrrrt", + "rtttrrti", + "rtttrrtr", + "rtttrrtt", + "rtttrt r", + "rtttrt t", + "rtttrtit", + "rtttrtrr", + "rtttrtrt", + "rtttrtt", + "rtttrttr", + "rtttrttt", + "rtttt", + "rtttt r", + "rtttt t", + "rtttt tt", + "rtttti", + "rttttii", + "rttttiii", + "rttttiit", + "rttttirr", + "rttttirt", + "rttttit", + "rttttiti", + "rttttitr", + "rttttitt", + "rttttrrr", + "rttttrrt", + "rttttrt", + "rttttrti", + "rttttrtr", + "rttttrtt", + "rttttt", + "rttttt t", + "rttttti", + "rtttttii", + "rtttttit", + "rtttttrr", + "rtttttrt", + "rtttttt", + "rtttttti", + "rttttttr", + "rttttttt", + "t", + "t rrr", + "t rrt", + "t rtr", + "t rtt", + "t rrr", + "t trrt", + "t tt", + "t rrrrr", + "t rtrtt", + "t t trt", + "t trt", + "t trtrr", + "t tt t", + "t tttr", + "t tttt", + "t i", + "t iiiirr", + "t iiitit", + "t rrrrrr", + "t rrrrrt", + "t rrrrtt", + "t rrrtrr", + "t rrrtt", + "t rrrttt", + "t rrt", + "t rrt rr", + "t rrtirr", + "t rrtrrr", + "t rrtrt", + "t rrtttr", + "t rrtttt", + "t rt", + "t rt rtt", + "t rtrrrr", + "t rtrrrt", + "t rtrtt", + "t rtrttt", + "t rttrrr", + "t rtttrt", + "t rttttr", + "t t", + "t t rr", + "t t rrr", + "t t t", + "t ti", + "t trrrrr", + "t trrrrt", + "t trrrtr", + "t trt", + "t trt rt", + "t trttt", + "t tt rt", + "t tt t t", + "t ttirtt", + "t ttittt", + "t ttrrrt", + "t ttrrtr", + "t tttrtr", + "t tttrtt", + "t ttttit", + "t ttttrt", + "t ttttti", + "t tttttt", + "ti", + "ti rrr", + "ti iiiir", + "ti iitti", + "ti ititi", + "ti t", + "ti trrtr", + "tii", + "tiii", + "tiiii", + "tiiiii", + "tiiiii t", + "tiiiiii", + "tiiiiiii", + "tiiiiiir", + "tiiiiiit", + "tiiiiirr", + "tiiiiirt", + "tiiiiit", + "tiiiiiti", + "tiiiiitr", + "tiiiiitt", + "tiiiirrr", + "tiiiirrt", + "tiiiirtt", + "tiiiit", + "tiiiit i", + "tiiiiti", + "tiiiitii", + "tiiiitit", + "tiiiitrr", + "tiiiitrt", + "tiiiitt", + "tiiiitti", + "tiiiittt", + "tiiirrrr", + "tiiirrtr", + "tiiirtii", + "tiiirtti", + "tiiirttr", + "tiiirttt", + "tiiit", + "tiiiti", + "tiiitii", + "tiiitiii", + "tiiitiit", + "tiiitirr", + "tiiititi", + "tiiititt", + "tiiitrrr", + "tiiitrrt", + "tiiitrtr", + "tiiitrtt", + "tiiitt", + "tiiittii", + "tiiittit", + "tiiittrr", + "tiiittrt", + "tiiittt", + "tiiittti", + "tiiitttr", + "tiiitttt", + "tiirrrrr", + "tiirrrrt", + "tiirrrt", + "tiirrrtt", + "tiirrt", + "tiirrtrr", + "tiirrtrt", + "tiirrttt", + "tiirt", + "tiirtit", + "tiirtrrr", + "tiirtttr", + "tiirtttt", + "tiit", + "tiiti", + "tiitiii", + "tiitiiii", + "tiitiiit", + "tiitiirr", + "tiitiirt", + "tiitiit", + "tiitiiti", + "tiitiitr", + "tiitiitt", + "tiitirrr", + "tiitit", + "tiititii", + "tiititit", + "tiititrr", + "tiititrt", + "tiititti", + "tiitittt", + "tiitrrrr", + "tiitrrrt", + "tiitrrtr", + "tiitrrtt", + "tiitrtit", + "tiitrttt", + "tiitt", + "tiitti", + "tiittiii", + "tiittiit", + "tiittirr", + "tiittitr", + "tiittitt", + "tiittrrr", + "tiittrtt", + "tiittt", + "tiitttii", + "tiitttir", + "tiitttit", + "tiitttt", + "tiitttti", + "tiittttt", + "tirrrrrr", + "tirrrrrt", + "tirrrrt", + "tirrrrti", + "tirrrrtr", + "tirrrrtt", + "tirrrt", + "tirrrtii", + "tirrrtit", + "tirrrtrr", + "tirrrtti", + "tirrrttr", + "tirrrttt", + "tirrt", + "tirrti", + "tirrtrrr", + "tirrtrrt", + "tirrtrti", + "tirrtrtt", + "tirrttrr", + "tirrttti", + "tirrtttt", + "tirt", + "tirt rtr", + "tirtii", + "tirtiiii", + "tirtiiit", + "tirtiirr", + "tirtiit", + "tirtirrr", + "tirtittt", + "tirtrrtt", + "tirtrtrr", + "tirtrtrt", + "tirtrtti", + "tirtt", + "tirttiir", + "tirttiti", + "tirttitr", + "tirttrrr", + "tirttrt", + "tirttrtt", + "tirttti", + "tirtttrr", + "tirtttrt", + "tirtttti", + "tirttttt", + "tit", + "titi", + "titi itt", + "titii", + "titiiii", + "titiiiii", + "titiiiit", + "titiiirr", + "titiiit", + "titiiiti", + "titiirrr", + "titiirtt", + "titiitit", + "titiitti", + "titiittr", + "titiittt", + "titirrrr", + "titirrtr", + "titirtii", + "titirtit", + "titit", + "tititiii", + "tititiit", + "tititirt", + "titititi", + "titititt", + "tititrrr", + "tititrrt", + "tititt", + "titittii", + "titittit", + "titittrr", + "titittt", + "titittti", + "tititttt", + "titrrrrr", + "titrrrrt", + "titrrrti", + "titrrrtr", + "titrrrtt", + "titrrtir", + "titrrtit", + "titrrtrt", + "titrrttt", + "titrtiii", + "titrtiti", + "titrtitt", + "titrtrrr", + "titrtrrt", + "titrtt", + "titrttrt", + "titrtttt", + "titt", + "titti", + "tittiiii", + "tittiiir", + "tittiiit", + "tittiirr", + "tittiiti", + "tittiitt", + "tittirrt", + "tittit", + "tittitii", + "tittitit", + "tittitt", + "tittittr", + "tittittt", + "tittrrrr", + "tittrrrt", + "tittrrtt", + "tittrtrr", + "tittrtti", + "tittrttt", + "tittt", + "tittt rr", + "tittti", + "titttii", + "titttiii", + "titttiit", + "titttit", + "titttiti", + "titttitr", + "titttitt", + "titttrrr", + "titttrrt", + "titttrtt", + "titttt", + "titttt t", + "titttti", + "tittttii", + "tittttit", + "tittttrr", + "tittttrt", + "tittttt", + "tittttti", + "titttttr", + "titttttt", + "tr", + "trr", + "trrrr", + "trrrrrr", + "trrrrrrr", + "trrrrrrt", + "trrrrrt", + "trrrrrti", + "trrrrrtr", + "trrrrrtt", + "trrrrt", + "trrrrt r", + "trrrrt t", + "trrrrti", + "trrrrtir", + "trrrrtit", + "trrrrtrr", + "trrrrtrt", + "trrrrtt", + "trrrrtti", + "trrrrttr", + "trrrrttt", + "trrrt", + "trrrt r", + "trrrt rr", + "trrrti", + "trrrtii", + "trrrtiii", + "trrrtiir", + "trrrtiit", + "trrrtirt", + "trrrtitr", + "trrrtrrr", + "trrrtrrt", + "trrrtrt", + "trrrtrtr", + "trrrtrtt", + "trrrtt", + "trrrtt t", + "trrrttit", + "trrrttr", + "trrrttrr", + "trrrttrt", + "trrrttt", + "trrrtttr", + "trrrtttt", + "trrt", + "trrt tr", + "trrt rrt", + "trrt rtr", + "trrt trr", + "trrt ttt", + "trrti", + "trrtii", + "trrtiiii", + "trrtiiir", + "trrtiiit", + "trrtiirr", + "trrtirrt", + "trrtirtt", + "trrtit", + "trrtitii", + "trrtitir", + "trrtitit", + "trrtitrt", + "trrtitt", + "trrtitti", + "trrtittt", + "trrtrrrr", + "trrtrrrt", + "trrtrrt", + "trrtrrti", + "trrtrrtr", + "trrtrrtt", + "trrtrt", + "trrtrt t", + "trrtrtii", + "trrtrtrr", + "trrtrtrt", + "trrtrtt", + "trrtrtti", + "trrtrttr", + "trrtrttt", + "trrtt", + "trrtt tt", + "trrttiii", + "trrttiit", + "trrttirt", + "trrttitr", + "trrttitt", + "trrttrrr", + "trrttrrt", + "trrttrt", + "trrttrtr", + "trrttrtt", + "trrttt", + "trrttti", + "trrtttii", + "trrtttit", + "trrtttrr", + "trrtttrt", + "trrtttt", + "trrtttti", + "trrttttr", + "trrttttt", + "trt", + "trt rrr", + "trt rrt", + "trt ttt", + "trt rrrr", + "trt rrrt", + "trt rrtt", + "trt t", + "trt trrr", + "trt trtt", + "trti", + "trti trr", + "trtii", + "trtiiii", + "trtiiiii", + "trtiiirr", + "trtiiirt", + "trtiiit", + "trtiirrr", + "trtiirtr", + "trtiitrr", + "trtiitrt", + "trtirrrr", + "trtirrrt", + "trtirrt", + "trtirrti", + "trtirrtt", + "trtirtit", + "trtit", + "trtitirr", + "trtitrrr", + "trtitt", + "trtittii", + "trtittrr", + "trtitttt", + "trtrr", + "trtrrrr", + "trtrrrrr", + "trtrrrrt", + "trtrrrt", + "trtrrrti", + "trtrrrtr", + "trtrrrtt", + "trtrrt", + "trtrrt t", + "trtrrtii", + "trtrrtrr", + "trtrrtrt", + "trtrrtt", + "trtrrtti", + "trtrrttr", + "trtrrttt", + "trtrt", + "trtrti", + "trtrtit", + "trtrtr", + "trtrtrrr", + "trtrtrrt", + "trtrtrt", + "trtrtrtr", + "trtrtrtt", + "trtrtt", + "trtrttrr", + "trtrttrt", + "trtrttt", + "trtrttti", + "trtrtttr", + "trtrtttt", + "trtt", + "trtt r", + "trtt rr", + "trtt t", + "trtti", + "trtti t", + "trttii", + "trttiii", + "trttiirr", + "trttiitt", + "trttirrt", + "trttit", + "trttitii", + "trttitti", + "trttittt", + "trttrrrr", + "trttrrrt", + "trttrrtr", + "trttrrtt", + "trttrti", + "trttrtrr", + "trttrtrt", + "trttrtt", + "trttrttr", + "trttrttt", + "trttt", + "trtttiii", + "trtttirr", + "trtttirt", + "trtttitt", + "trtttrrr", + "trtttrrt", + "trtttrt", + "trtttrtr", + "trtttrtt", + "trtttt", + "trtttti", + "trttttii", + "trttttit", + "trttttrr", + "trttttrt", + "trttttt", + "trttttti", + "trtttttr", + "trtttttt", + "tt", + "tt tt", + "tt t t", + "tt tt", + "tt iiii", + "tt rrr", + "tt rtrt", + "tt tttr", + "tt tttt", + "tt i", + "tt iitt", + "tt rrrrr", + "tt rrt", + "tt rrtrt", + "tt rt", + "tt rtrrt", + "tt rttrt", + "tt rtttt", + "tt t", + "tt t rrr", + "tt ti", + "tt tiiti", + "tt tittt", + "tt trt", + "tt tt", + "tt ttiii", + "tt ttt", + "tt tttrt", + "tt ttttt", + "tti", + "tti ii", + "tti ttt", + "ttii", + "ttii iii", + "ttiii", + "ttiiii", + "ttiiiii", + "ttiiiiii", + "ttiiiiir", + "ttiiiiit", + "ttiiiirr", + "ttiiiirt", + "ttiiiiti", + "ttiiiitr", + "ttiiiitt", + "ttiiirrr", + "ttiiirrt", + "ttiiitii", + "ttiiitir", + "ttiiitit", + "ttiiitrr", + "ttiiitt", + "ttiiitti", + "ttiiittt", + "ttiirrrr", + "ttiirrtt", + "ttiirt", + "ttiirtii", + "ttiirtti", + "ttiirttr", + "ttiirttt", + "ttiit", + "ttiiti", + "ttiitii", + "ttiitiii", + "ttiitiit", + "ttiititi", + "ttiititr", + "ttiititt", + "ttiitrrr", + "ttiitrrt", + "ttiitrtr", + "ttiitrtt", + "ttiitti", + "ttiittii", + "ttiittit", + "ttiittrr", + "ttiittrt", + "ttiittt", + "ttiittti", + "ttiitttr", + "ttiitttt", + "ttirrrrr", + "ttirrrrt", + "ttirrrt", + "ttirrrtr", + "ttirrrtt", + "ttirrti", + "ttirrtit", + "ttirrtrr", + "ttirrtti", + "ttirrttr", + "ttirrttt", + "ttirtiit", + "ttirtitr", + "ttirtrrr", + "ttirtrrt", + "ttirtrtr", + "ttirttrr", + "ttirttrt", + "ttirttt", + "ttirtttr", + "ttirtttt", + "ttit", + "ttit rrr", + "ttiti", + "ttitiii", + "ttitiiii", + "ttitiiit", + "ttitiit", + "ttitiiti", + "ttitirrr", + "ttitit", + "ttititii", + "ttititit", + "ttititrr", + "ttititrt", + "ttititt", + "ttititti", + "ttitittr", + "ttitittt", + "ttitrrrr", + "ttitrrti", + "ttitrrtr", + "ttitrrtt", + "ttitrt i", + "ttitrtrr", + "ttitrtrt", + "ttitrtt", + "ttitrttr", + "ttitrttt", + "ttitt", + "ttittiii", + "ttittiir", + "ttittiit", + "ttittit", + "ttittiti", + "ttittitt", + "ttittrrr", + "ttittrrt", + "ttittrtr", + "ttittrtt", + "ttittt", + "ttittti", + "ttitttii", + "ttitttit", + "ttitttrr", + "ttitttrt", + "ttitttt", + "ttitttti", + "ttittttr", + "ttittttt", + "ttrrrrr", + "ttrrrrrr", + "ttrrrrrt", + "ttrrrrt", + "ttrrrrti", + "ttrrrrtr", + "ttrrrrtt", + "ttrrrtii", + "ttrrrtit", + "ttrrrtrr", + "ttrrrtrt", + "ttrrrtt", + "ttrrrtti", + "ttrrrttr", + "ttrrrttt", + "ttrrt", + "ttrrt t", + "ttrrti", + "ttrrtiii", + "ttrrtirt", + "ttrrtitt", + "ttrrtrr", + "ttrrtrrr", + "ttrrtrrt", + "ttrrtrt", + "ttrrtrtr", + "ttrrtrtt", + "ttrrtt", + "ttrrttir", + "ttrrttrr", + "ttrrttrt", + "ttrrttt", + "ttrrttti", + "ttrrtttr", + "ttrrtttt", + "ttrt", + "ttrt tr", + "ttrt ttt", + "ttrtiiit", + "ttrtiit", + "ttrtiiti", + "ttrtiitt", + "ttrtirrr", + "ttrtirrt", + "ttrtirtt", + "ttrtitii", + "ttrtitrr", + "ttrtittt", + "ttrtrrr", + "ttrtrrrr", + "ttrtrrrt", + "ttrtrrt", + "ttrtrrtr", + "ttrtrrtt", + "ttrtrt", + "ttrtrt r", + "ttrtrtrr", + "ttrtrtrt", + "ttrtrtt", + "ttrtrttr", + "ttrtrttt", + "ttrtt", + "ttrtti", + "ttrttiii", + "ttrttit", + "ttrttitt", + "ttrttrrr", + "ttrttrrt", + "ttrttrtr", + "ttrttrtt", + "ttrttt", + "ttrttt r", + "ttrtttii", + "ttrtttir", + "ttrtttrr", + "ttrtttrt", + "ttrtttt", + "ttrtttti", + "ttrttttr", + "ttrttttt", + "ttt", + "ttt tt", + "ttt iii", + "ttt trt", + "ttt ttt", + "ttt it r", + "ttt itit", + "ttt rrrr", + "ttt rrrt", + "ttt rrtr", + "ttt rttt", + "ttt t t", + "ttt t tr", + "ttt titt", + "ttt trtt", + "ttt tt", + "ttt tt t", + "ttt tttt", + "ttti", + "ttti ti", + "tttii", + "tttiii", + "tttiiii", + "tttiiiii", + "tttiiiir", + "tttiiiit", + "tttiiirr", + "tttiiit", + "tttiiiti", + "tttiiitt", + "tttiirrr", + "tttiirrt", + "tttiitii", + "tttiitit", + "tttiitrr", + "tttiitrt", + "tttiitt", + "tttiitti", + "tttiittr", + "tttiittt", + "tttirrrr", + "tttirrtr", + "tttirtrr", + "tttit", + "tttiti", + "tttitii", + "tttitiii", + "tttitiit", + "tttitirt", + "tttititi", + "tttititr", + "tttititt", + "tttitr", + "tttitrrr", + "tttitrrt", + "tttitrti", + "tttitrtr", + "tttitrtt", + "tttitt", + "tttitti", + "tttittii", + "tttittit", + "tttittrr", + "tttittrt", + "tttittt", + "tttittti", + "tttitttr", + "tttitttt", + "tttrrrr", + "tttrrrrr", + "tttrrrrt", + "tttrrrt", + "tttrrrti", + "tttrrrtr", + "tttrrrtt", + "tttrrt", + "tttrrtii", + "tttrrtit", + "tttrrtrr", + "tttrrtrt", + "tttrrtt", + "tttrrtti", + "tttrrttr", + "tttrrttt", + "tttrt", + "tttrt rt", + "tttrt tt", + "tttrtit", + "tttrtitr", + "tttrtrrr", + "tttrtrrt", + "tttrtrt", + "tttrtrtr", + "tttrtrtt", + "tttrtt", + "tttrttii", + "tttrttit", + "tttrttr", + "tttrttrr", + "tttrttrt", + "tttrttt", + "tttrttti", + "tttrtttr", + "tttrtttt", + "tttt", + "tttt t", + "tttt rr", + "tttt t", + "tttt iii", + "tttt irr", + "tttt rt", + "tttt rtt", + "tttt t", + "tttt tii", + "tttt tit", + "tttt trt", + "tttt ttr", + "tttt ttt", + "tttti", + "tttti t", + "ttttii", + "ttttiii", + "ttttiiii", + "ttttiiir", + "ttttiiit", + "ttttiirr", + "ttttiirt", + "ttttiit", + "ttttiiti", + "ttttiitr", + "ttttiitt", + "ttttirrr", + "ttttirrt", + "ttttirtt", + "ttttit", + "ttttit r", + "ttttiti", + "ttttitii", + "ttttitit", + "ttttitrr", + "ttttitrt", + "ttttitt", + "ttttitti", + "ttttittr", + "ttttittt", + "ttttrrrr", + "ttttrrrt", + "ttttrrt", + "ttttrrtr", + "ttttrrtt", + "ttttrt", + "ttttrt r", + "ttttrt t", + "ttttrtii", + "ttttrtir", + "ttttrtit", + "ttttrtr", + "ttttrtrr", + "ttttrtrt", + "ttttrtt", + "ttttrtti", + "ttttrttr", + "ttttrttt", + "ttttt", + "ttttt r", + "ttttt t", + "ttttt ii", + "ttttt it", + "ttttt rt", + "ttttt t", + "ttttt ti", + "ttttt tr", + "ttttt tt", + "ttttti", + "tttttii", + "tttttiii", + "tttttiir", + "tttttiit", + "tttttirr", + "tttttirt", + "tttttit", + "tttttiti", + "tttttitr", + "tttttitt", + "tttttrr", + "tttttrrr", + "tttttrrt", + "tttttrt", + "tttttrti", + "tttttrtr", + "tttttrtt", + "tttttt", + "tttttt r", + "tttttt t", + "tttttti", + "ttttttii", + "ttttttir", + "ttttttit", + "ttttttr", + "ttttttri", + "ttttttrr", + "ttttttrt", + "ttttttt", + "ttttttti", + "tttttttr", + "tttttttt" + ] +} \ No newline at end of file diff --git a/request_schema.json b/request_schema.json index 0967ef4..2838865 100644 --- a/request_schema.json +++ b/request_schema.json @@ -1 +1,11 @@ -{} +{ + "$schema": "http://json-schema.org/draft-07/schema", + "type": "object", + "properties": { + "results": { + "type": ["array", "null"], + "items": {"type": "object"} + } + }, + "required": [] +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 0967ef4..37784f2 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1 +1,4 @@ -{} +joblib==1.5.2 +numpy==2.2.6 +pandas==2.2.3 +xgboost==3.1.1 \ No newline at end of file diff --git a/response_schema.json b/response_schema.json index 0967ef4..bab5a63 100644 --- a/response_schema.json +++ b/response_schema.json @@ -1 +1,11 @@ -{} +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "properties": { + "pd_a": { "type": "number" }, + "pd_b": { "type": "number" }, + "pd_t": { "type": "number" } + }, + "required": ["pd_a", "pd_b", "pd_t"], + "additionalProperties": false +} \ No newline at end of file diff --git a/test_block.py b/test_block.py new file mode 100644 index 0000000..b68a8b7 --- /dev/null +++ b/test_block.py @@ -0,0 +1,18 @@ +import unittest +from block import __main__ +# from reference import __main__ + + +data = [{'model_a_features': {'AEPMAG05': 297, 'RET201': None, 'PER201': 1.0, 'PER202': 1.0, 'PER222': 1.0, 'PER225': 1.51, 'PER235': 1949, 'CTM18': None, 'SC20S': None, 'AT36SD': 6, 'FI36SD': 999, 'G250BD': 1, 'G250CD': 1, 'US36SD': 999, 'CV13': 3.0, 'CV25': 0.0, 'CV26': 3.0, 'AT01S': 36, 'AT104S': 8, 'FI02S': 1, 'FI20S': 119, 'FI35S': 1225, 'G051S': 3, 'G205S': 611, 'G210S': None, 'G218A': 0, 'G225S': 606, 'G230S': None, 'G234S': None, 'G300S': 1, 'IN02S': 1, 'IN12S': 1, 'OF20S': None, 'RT20S': 114, 'INAP01': 175, 'G106S': 220, 'US02S': 1, 'US20S': 119, 'US24S': 1, 'US28S': 1449, 'US32S': 1225, 'US35S': 1225, 'US36S': None, 'SE20S': None, 'US51A': 12, 'G205B': 611, 'INST_TRD': 28, 'RTL_TRD': 8, 'AGG402': 210, 'AGG403': 205, 'AGG423': 1344, 'AGG424': 484, 'AGG903': 1, 'TRV03': 3, 'TRV04': 5, 'BALMAG01': 188, 'score_results': 603, 'PER201_unk': 0, 'G225S_unk': 0, 'SC20S_unk': 1, 'RET201_unk': 1, 'US24S_unk': 0}, 'model_b_features': {'UTLMAG01': 112, 'AEPMAG04': 286, 'PER201': 1.0, 'PER203': 1.31, 'PER222': 1.0, 'PER223': 1.31, 'PER224': 1.15, 'PER225': 1.51, 'PER235': 1949, 'CTM23': None, 'CT321': 65, 'CTC20': None, 'CTA17': 24, 'CTA18': 5, 'SC21S': None, 'SCC92': None, 'SCBALM01': None, 'AT36SD': 6, 'FI36SD': 999, 'RE36SD': 6, 'SE36SD': None, 'US36SD': 999, 'LQA232YR': 100.0, 'LQR325YR': -255.0, 'RLE902': None, 'CV25': 0.0, 'CV26': 3.0, 'RVDEXQ2': 9, 'AT01S': 36, 'AT104S': 8, 'AU20S': None, 'BI21S': None, 'BR33S': 1148, 'CO06S': None, 'FI02S': 1, 'FI03S': 1, 'FI20S': 119, 'FI32S': 1225, 'FI33S': 1225, 'FI34S': 85, 'FI35S': 1225, 'FI101S': 1225, 'FR21S': None, 'FR32S': None, 'G020S': 11, 'G102S': None, 'G205S': 611, 'G210S': None, 'G213A': None, 'G225S': 606, 'G234S': None, 'G301S': 1, 'G990S': None, 'IN02S': 1, 'IN12S': 1, 'MT21S': None, 'OF09S': None, 'OF21S': None, 'OF29S': None, 'OF35S': None, 'RE32S': 2384, 'RT36S': 6, 'ST01S': 0, 'INAP01': 175, 'G106S': 220, 'S204S': None, 'US02S': 1, 'US03S': 1, 'US12S': 1, 'US20S': 119, 'US24S': 1, 'US30S': 100.0, 'US34S': 85, 'SE20S': None, 'SE21S': None, 'SE34S': None, 'SE36S': None, 'JT20S': None, 'JT33S': None, 'JT70S': None, 'G404S': None, 'G405S': None, 'G406S': None, 'G407S': None, 'G416S': None, 'G417S': None, 'US51A': 12, 'INST_TRD': 28, 'NOMT_TRD': 36, 'AGG512': 1169, 'AGG516': 1193, 'AGG902': 2, 'AGG903': 1, 'TRV03': 3, 'TRV04': 5, 'TRV06': 8, 'BALMAG01': 188, 'RVLR14': 'RTRRRRRR', 'PAYMNT06': 1.31, 'PAYMNT07': 1.0, 'score_results': 603}, 'model_t_features': {'PDMAG01': 310, 'AEPMAG05': 297, 'AUT201': None, 'PER201': 1.0, 'PER203': 1.31, 'PER204': 1.15, 'PER205': 1.48, 'PER223': 1.31, 'PER225': 1.51, 'PER253': 54, 'CTA17': 24, 'SE21CD': None, 'RLE907': None, 'CV26': 3.0, 'AT35B': 1037, 'FI28S': 1449, 'FI32S': 1225, 'INAP01': 175, 'US01S': 26, 'US28S': 1449, 'US34S': 85, 'US101S': 1225, 'SE02S': None, 'SE06S': None, 'SE09S': None, 'SE20S': None, 'TRV06': 8, 'TRV10': 12, 'PAYMNT06': 1.31, 'AEPMAG05_unk': 0, 'PER201_unk': 0}}] + +class TestBlock(unittest.TestCase): + def test_main_returns_scores(self): + block_result = __main__(data) + print(block_result) + self.assertIsInstance(block_result, dict) + self.assertIn("pd_a", block_result) + self.assertIn("pd_b", block_result) + self.assertIn("pd_t", block_result) + +if __name__ == "__main__": # pragma: no cover + unittest.main() diff --git a/xgboost_model_A.joblib b/xgboost_model_A.joblib new file mode 100644 index 0000000..36c39a5 Binary files /dev/null and b/xgboost_model_A.joblib differ diff --git a/xgboost_model_B.joblib b/xgboost_model_B.joblib new file mode 100644 index 0000000..1668266 Binary files /dev/null and b/xgboost_model_B.joblib differ diff --git a/xgboost_model_T.joblib b/xgboost_model_T.joblib new file mode 100644 index 0000000..e89f045 Binary files /dev/null and b/xgboost_model_T.joblib differ